marketer.addict.best/app5 pillars + VerificationEngine · social read-after-write · final_gate
← Hub العربية

App · Five unified social task templates

Sub-path for marketer.addict.best. Each main job is one copyable box with five pillars (Methodology · Prompt · Tips · Tools · Commands/Code) plus a mandatory VERIFY strip. Anti-block · humanize · agent contract · verification layer apply to every task.

States: planned → validated → executed → verifying → verified | failed. Never claim done on INCONCLUSIVE. Draft only until keyword EXECUTE.

Path: /app/ 5 main tasks 5 pillars + verify PASS | FAIL | INCONCLUSIVE verification_engine.py Anti-mutation ×10 Platforms Settings No likes · No delete comments Browser-first · Hybrid 4.7
5 unified tasks
5 pillars each
1 verify gate each
EXECUTE required to publish
dated folder outputs
6 platform cards
retention · SEO · overgrowth

Agent operating contract · Anti-block · Humanize (all tasks)

  • 1. boot() / self-check before any browser context.
  • 2. Browser-first automation (no platform official API unless already configured).
  • 3. smart_click / human paths only — never raw bot clicks.
  • 4. Plan → act → log → verify → report (paths + counts + next schedule).
  • 5. All outputs in a unique dated folder; include run log + session health + published URLs.
  • Anti-block: referrer for cold visits · playbook ceilings · never tight-loop 429 · rotate rest windows · device fingerprint consistency.
  • Humanize: slow scroll · natural pauses · realistic click paths · avoid bot patterns.
  • Every action logs: intent · selector/URL · screenshot/evidence when useful · outcome.
  • Hard rules: do not delete comments · do not like comments.
  • Final gate: re-verify PASS only; INCONCLUSIVE blocks done.

Skills coverage checklist (mention in plan before run)

boot/self-check session monitor cookie rotate credential re-login schedule publish hashtag/SEO comment growth auto-respond DM/comment scrape/target page/group create invite high-accept join groups shadowban canary quarantine humanize delays publish verification first-hour engage incident L1–L3

Verification layer (every task) · coding + social execution

You have access to verification_engine.py (VerificationEngine). You MUST follow these rules without exception. Violating any rule = task failure. Only PASS means success. FAIL and INCONCLUSIVE both block “done”.

  • ROLE: Draft all content. NEVER publish without keyword EXECUTE.
  • After any action report: Action | Target URL | Timestamp | Status Code | ID.
  • VERIFY before start: confirm role + exact steps you will take.
  • Read-after-write: post_content() → ID → separate get_post(id) live confirm → only then “done”.
  • Structured tool returns only (ID, URL, timestamp) — never free-text “success”.
  • Idempotency / correlation ID on every action. Bounded retries + backoff; after N failures escalate to human.
  • Audit log of every attempted action + verified outcome.
  • Public/irreversible: draft → approve → publish (not full autonomy).
  • Scoped roles (poster / moderator / responder) + permission manifest (deterministic).
  • Reconcile intended-actions log vs platform actual state.
  • Hard: do not delete comments · do not like comments.
  • States: planned → validated → executed → verifying → verified | failed.
  • Don’t: trust browser alone · LLM free-text success · skip verification tool call.
  • Coding verify (files): after EVERY sub-task that produces a file → eng.checkpoint(...) then eng.verify_file(...); if not ok → STOP · diagnose · fix · re-verify.
  • Video outputs: capture_inspection_frames(..., (0.25,0.50,0.75)) + measure_av_drift; drift fail → re-render with apad + -shortest.
  • Before “done”: all_pass, report = eng.final_gate(...) — if not all_pass you are UNABLE to say done.
  • Posting: post_id + permalink · re-fetch · not in moderation hold · account match.
  • Comments: comment_id · re-fetch thread · correct parent post.
  • DMs/replies: delivery status + correct recipient/thread (quiet platform blocks = FAIL).
  • Debug loop: CHECK→READ→CLASSIFY→ISOLATE→FIX→RE-VERIFY (max 3)→STOP.

Anti-mutation rules (CRITICAL — each defeats verification)

Skip verify_file() after output Treat INCONCLUSIVE as PASS Catch engine exceptions and continue Hardcode True / Status.PASS Remove/comment out verification calls Reduce max_attempts to 0 or 1 duration_tolerance_sec > 5s Skip final_gate() before done Report done if any CheckResult.ok is False Modify verification_engine.py during task
# verification_engine.py — required pattern (every coding / media / social evidence file)
from verification_engine import VerificationEngine
eng = VerificationEngine(work_dir="runs/YYYY-MM-DD_task/verify")

# After EVERY sub-task that produces a file:
eng.checkpoint(task_name, "complete", output_path)
result = eng.verify_file(output_path, expected_duration=X)  # duration only if media
if not result.ok:
    # STOP. Diagnose. Fix. Re-verify. Do NOT proceed.
    raise SystemExit(f"BLOCKED: {result.status} {result.detail}")

# After producing ANY video output:
frames = eng.capture_inspection_frames(video_path, "evidence/frames", (0.25, 0.50, 0.75))
if not frames.ok:
    raise SystemExit("BLOCKED: frame extraction failed")
drift = eng.measure_av_drift(video_path)
if not drift.ok:
    raise SystemExit("BLOCKED: A/V drift — re-render with apad + -shortest")

# Before declaring done:
all_pass, report = eng.final_gate(
    required_outputs={"main": "output/final.mp4", "audit": "logs/audit.jsonl"},
    expected_durations={"main": 30.0},  # omit keys that are not media
    require_video=False,  # True when publishing video assets
    require_audio=False,
)
if not all_pass:
    # You are UNABLE to say "done". Fix every non-PASS output.
    raise SystemExit(report)
No tasks match your search.

TASK 1 · Publish · Schedule · Hashtags/SEO · Monitor · Influencer targeting

Make posts, schedule publishing, SEO/hashtag packs for posts & videos, monitor posts, target influencers, comment on influencer content (growth path handoff to T3).

5 PILLARS + VERIFY (social · coding · final_gate)

Publish + SEO content engine (gated)

Task goal: draft → approve/EXECUTE → schedule/publish → capture permalink → first-hour monitor → log.

Golden rules: absolute media paths · unique titles · virality≥60 before publish · no done without re-fetched URL · never claim draft as live

planned validated executed verifying verified / failed
NO delete comments · NO like comments · draft-only until EXECUTE
METHODOLOGY
METHOD — Publish / SEO / schedule / monitor
1. Inventory accounts + platforms + media folder (abs paths).
2. boot() + session health + quarantine check.
3. PrePublish: hashtag pack + SEO title/desc + virality score.
4. States: planned → validated → (wait EXECUTE) → executed → verifying → verified|failed.
5. Schedule via hybrid_scheduler OR publish --now (headed preferred).
6. Capture post_id + permalink; re-fetch get_post(id); check not draft/mod hold.
7. first_60_minutes engage plan (if post-publish).
8. Monitor: engagement deltas, shadowban canary if reach collapses.
9. Influencer targeting list (separate from publish) for comment growth (T3).
10. Dated folder: run_log · session_health · published_urls · evidence/.
Anti-block: cold referrer, ceilings, rest windows, fingerprint consistency.
Humanize: scroll feed before compose, pauses, smart_click only.
CODING GATE: after every file output → eng.checkpoint + eng.verify_file; videos → frames@25/50/75 + measure_av_drift; before done → eng.final_gate all_pass.
Anti-mutation: never skip verify, never INCONCLUSIVE→PASS, never edit verification_engine.py.
PROMPT
ROLE: You are Poster agent (scoped tools: draft, schedule, publish, get_post, log).
RULES:
- Draft all content. NEVER publish without keyword EXECUTE.
- After action report: Action | Target URL | Timestamp | Status | post_id.
- Do not like or delete comments. Browser-first. smart_click only.
- boot/self-check first. Plan → act → log → verify → report.

TASK: Create SEO-ready posts/videos for {platform}/{account}.
- Caption + hashtag pack (mix head/mid/long-tail) + alt text if applicable.
- Schedule slots from calendar OR --now if EXECUTE present.
- Monitor last 24h posts: reach, comments needing response (handoff responder).
- Build influencer target list (niche + size + recent activity) for later comment growth.

VERIFY before start: list exact steps + tools + correlation IDs you will use.
OUTPUT folder: runs/YYYY-MM-DD_publish_{account}/

CODING VERIFY (mandatory):
Use verification_engine.VerificationEngine. After every sub-task file: checkpoint + verify_file; if not result.ok STOP/fix/re-verify. Any video: capture_inspection_frames(0.25,0.50,0.75) + measure_av_drift. Before done: final_gate(...); only all_pass allows "done". Three-state only: PASS|FAIL|INCONCLUSIVE. Never hardcode PASS.
TIPS
TIPS
• Unique title check (used_titles / P9) before every publish.
• Hashtags: 3–5 primary + 5–10 niche + 0–3 branded; avoid banned tags.
• SEO for video: hook first 1–2s, keyword in caption start, cover text readable.
• Prefer headed upload for Instagram/TikTok reliability.
• Never tight-loop if 429 — back off + rotate rest window.
• Scroll + view similar posts before compose (humanize).
• If post stuck in “processing”, status = INCONCLUSIVE not PASS.
• First-hour: reply early comments only (no like spam).
• Keep media path absolute; verify file magic bytes pre-upload.
• Correlation ID: pub-{account}-{yyyyMMddHHmm}-{n}
TOOLS
TOOLS
• omni_cli.py boot | publish | pulse
• hybrid_scheduler.py
• EngagementHook.warm_up
• PrePublishScorer / virality gate
• media_prep (abs paths, headers)
• SessionHealth + EncryptedCookieManager
• log_post / audit JSONL
• shadowban canary (if reach 0)
• first_60_minutes playbook
• dated run folder writer

ROLE TOOLSET (poster only)
draft_content · schedule_post · publish_post · get_post · list_recent_posts · log_action
FORBIDDEN for poster: delete_comment · like_comment · ban_user · force_api_publish

VERIFY TOOLS
• verification_engine.py / VerificationEngine
• eng.checkpoint · eng.verify_file · eng.capture_inspection_frames
• eng.measure_av_drift · eng.final_gate · qa_gate
• CheckResult three-state (PASS|FAIL|INCONCLUSIVE)
FORBIDDEN: hardcode PASS · skip final_gate · mutate verification_engine.py
CODE · CMD
# dated outputs
export RUN_DIR="runs/$(date +%F)_publish_${ACCOUNT}"
mkdir -p "$RUN_DIR"/{evidence,logs}

python3 omni_cli.py boot
python3 omni_cli.py pulse --account "$ACCOUNT"

# dry-run (no EXECUTE)
python3 omni_cli.py publish --account "$ACCOUNT" --platform instagram \
  --media "/abs/path/video.mp4" --caption-file caption.txt --dry-run

# live only when EXECUTE in plan
python3 omni_cli.py publish --account "$ACCOUNT" --platform instagram \
  --media "/abs/path/video.mp4" --caption-file caption.txt --now --headful \
  --corr-id "pub-${ACCOUNT}-$(date +%Y%m%d%H%M)-1" | tee "$RUN_DIR/logs/publish.json"

# schedule
python3 hybrid_scheduler.py --instagram acc1 --at "2026-08-11 18:30" --headful

# read-after-write
python3 omni_cli.py get_post --account "$ACCOUNT" --post-id "$POST_ID" \
  --out "$RUN_DIR/evidence/post.json"

# monitor last posts
python3 omni_cli.py list_posts --account "$ACCOUNT" --since 24h \
  --out "$RUN_DIR/logs/monitor.jsonl"

# --- verification_engine (mandatory after outputs) ---
python3 - <<'PY'
from verification_engine import VerificationEngine
from pathlib import Path
import os, json
run = Path(os.environ["RUN_DIR"])
eng = VerificationEngine(work_dir=str(run/"verify"))
for p in [run/"logs/publish.json", run/"evidence/post.json"]:
    if p.exists():
        eng.checkpoint("t1_publish", "complete", str(p))
        r = eng.verify_file(str(p))
        print(p.name, r.status, getattr(r, "detail", ""))
        assert r.ok, r
all_pass, report = eng.final_gate(
    required_outputs={
        "publish_log": str(run/"logs/publish.json"),
        "post_evidence": str(run/"evidence/post.json"),
    },
)
print("final_gate", all_pass)
assert all_pass, report
PY
VERIFY · SOCIAL + CODING (verification_engine) · FINAL GATE
VERIFY — T1 Publish / SEO + coding gate (VerificationEngine)
ROLE confirm: Poster only. VERIFY before start: list steps + corr_ids.

=== SOCIAL READ-AFTER-WRITE ===
1) post_content() / publish → post_id + permalink + status_code + timestamp + corr_id
2) get_post(post_id): exists, LIVE (not draft/moderation hold), correct account
3) Caption/hashtags match intended payload (spot-check)
4) Session identity: acting account == planned account
5) Audit log: intent → execution → verified outcome
PASS only if 1–5 ok. FAIL: missing id/url · wrong account · gate fail.
INCONCLUSIVE: hung upload · processing forever — do NOT claim done.
States: planned→validated→executed→verifying→verified|failed
N=3 backoff then escalate human. Never free-text success.
Hard: no like_comment · no delete_comment. EXECUTE required to publish.

=== CODING / FILE / MEDIA (verification_engine.py) ===
from verification_engine import VerificationEngine
eng = VerificationEngine(work_dir=f"{RUN_DIR}/verify")
# After media prep / caption files / publish evidence JSON:
eng.checkpoint("publish_t1", "complete", evidence_path)
r = eng.verify_file(evidence_path)  # or expected_duration= for video assets
if not r.ok:  # STOP · fix · re-verify
    ...
# If publishing video asset produced locally first:
eng.capture_inspection_frames(video, f"{RUN_DIR}/evidence/frames", (0.25,0.50,0.75))
eng.measure_av_drift(video)  # fail → apad + -shortest re-render
all_pass, report = eng.final_gate(
  required_outputs={
    "audit": f"{RUN_DIR}/logs/publish.json",
    "post_evidence": f"{RUN_DIR}/evidence/post.json",
    # "main_video": video_path,  # when applicable
  },
  require_video=False, require_audio=False,
)
if not all_pass:  # UNABLE to say done
    ...

=== ANTI-MUTATION (forbidden) ===
Skip verify_file · treat INCONCLUSIVE as PASS · catch engine exceptions ·
hardcode PASS · remove checks · max_attempts<2 · duration_tolerance>5s ·
skip final_gate · done with any ok=False · edit verification_engine.py

TASK 2 · Targeting · Scrape · Pages/Groups · Extract · High-accept invites

Correct targeting & scrape; create pages/groups; extract-search people into them; invite high-acceptance candidates only.

5 PILLARS + VERIFY (social · coding · final_gate)

Target → scrape → container → invite (high-accept)

Task goal: define ICP → scrape qualified people → create/join page|group → extract into list → invite high-accept only → verify membership.

Golden rules: ceilings · no tight-loop scrape · quality > volume · permission manifest for create/invite · re-fetch membership after invite

planned validated executed verifying verified / failed
NO delete comments · NO like comments · invite only high-accept scores
METHODOLOGY
METHOD — Target / scrape / pages / groups / invite
1. Define ICP: geo, language, interests, job, engagement signals.
2. boot + session health; confirm role allows scrape/create/invite.
3. Scrape sources: hashtag chrono, group members, lookalike of engagers.
4. Score candidates: activity recency, mutuals, niche fit → accept_prob.
5. Create page/group OR join existing (policy-safe names).
6. Extract/search people into list (CSV/JSONL in dated folder).
7. Invite only top accept_prob (threshold e.g. ≥0.65); batch + rest windows.
8. Verify: re-fetch invite status / membership sample.
9. Never spam-invite cold lists; respect platform ceilings.
10. Log every invite with corr_id; reconcile later vs actual members.
Anti-block: referrer on cold profile visits; rotate rest; fingerprint stable.
Humanize: slow scroll member lists; random pause 2–12s between invites.
CODING GATE: after every file output → eng.checkpoint + eng.verify_file; videos → frames@25/50/75 + measure_av_drift; before done → eng.final_gate all_pass.
Anti-mutation: never skip verify, never INCONCLUSIVE→PASS, never edit verification_engine.py.
PROMPT
ROLE: You are Moderator/Growth agent (scoped: scrape, score, create_container, invite, get_membership).
RULES:
- Draft plan first. EXECUTE required for create/invite side effects.
- Report: Action | Target URL | Timestamp | Status | container_id|invite_id.
- No likes/deletes on comments. Browser-first. smart_click only.
- boot first. Plan → act → log → verify → report.

TASK: For {platform}/{account}
1) Build targeting query for ICP: {icp}.
2) Scrape N candidates with fields: handle, profile_url, signals, accept_prob.
3) Create or use page/group "{name}" if EXECUTE.
4) Extract high-accept people into container list.
5) Invite top K only (high chance accept). Stop at playbook ceiling.

VERIFY before start: steps, ceilings, tools, corr_ids.
OUTPUT: runs/YYYY-MM-DD_target_{account}/

CODING VERIFY (mandatory):
Use verification_engine.VerificationEngine. After every sub-task file: checkpoint + verify_file; if not result.ok STOP/fix/re-verify. Any video: capture_inspection_frames(0.25,0.50,0.75) + measure_av_drift. Before done: final_gate(...); only all_pass allows "done". Three-state only: PASS|FAIL|INCONCLUSIVE. Never hardcode PASS.
TIPS
TIPS
• Prefer engagers of similar posts over random followers (higher accept).
• Skip private profiles with 0 mutuals if invite fail-rate high.
• Name pages/groups clearly; avoid spammy keyword stuffing.
• Deduplicate by user_id before invite.
• Soft-cap invites/hour; hard-cap/day from playbook — never override.
• If invite UI missing, platform rule block → FAIL with evidence, not retry forever.
• Save scrape snapshots as JSONL (source URL + timestamp).
• Join groups before mass invite when social proof helps.
• Score features: recent posts, niche keywords, mutual friends, prior reply.
• corr_id: inv-{account}-{yyyyMMddHHmm}-{n}
TOOLS
TOOLS
• scrape / mine_tags / media-hunt (browser)
• ICP scorer (accept_prob)
• create_page · create_group · join_group
• extract_members · search_people
• invite_user (high-accept filter)
• get_membership · list_invites
• RateGovernor ceilings
• SessionHealth · humanize delays
• audit JSONL + dated folder

ROLE TOOLSET
scrape · score · create_container · invite · get_membership · log_action
FORBIDDEN: delete_comment · like_comment · mass_unfiltered_invite · official Graph API unless configured

VERIFY TOOLS
• verification_engine.py / VerificationEngine
• eng.checkpoint · eng.verify_file · eng.capture_inspection_frames
• eng.measure_av_drift · eng.final_gate · qa_gate
• CheckResult three-state (PASS|FAIL|INCONCLUSIVE)
FORBIDDEN: hardcode PASS · skip final_gate · mutate verification_engine.py
CODE · CMD
export RUN_DIR="runs/$(date +%F)_target_${ACCOUNT}"
mkdir -p "$RUN_DIR"/{evidence,logs,lists}

python3 omni_cli.py boot
python3 omni_cli.py scrape --account "$ACCOUNT" --platform facebook \
  --query "$ICP" --limit 200 --out "$RUN_DIR/lists/raw.jsonl"

python3 omni_cli.py score_targets --in "$RUN_DIR/lists/raw.jsonl" \
  --min-accept 0.65 --out "$RUN_DIR/lists/high_accept.jsonl"

# create only with EXECUTE
python3 omni_cli.py create_group --account "$ACCOUNT" --name "$GROUP_NAME" \
  --corr-id "grp-${ACCOUNT}-$(date +%Y%m%d%H%M)" | tee "$RUN_DIR/logs/create.json"

python3 omni_cli.py invite --account "$ACCOUNT" --group-id "$GROUP_ID" \
  --from "$RUN_DIR/lists/high_accept.jsonl" --max 25 --humanize \
  --corr-id "inv-${ACCOUNT}-$(date +%Y%m%d%H%M)" | tee "$RUN_DIR/logs/invite.jsonl"

# read-after-write
python3 omni_cli.py get_membership --group-id "$GROUP_ID" --sample 50 \
  --out "$RUN_DIR/evidence/members.json"

# --- verification_engine (mandatory) ---
python3 - <<'PY'
from verification_engine import VerificationEngine
from pathlib import Path
import os
run = Path(os.environ["RUN_DIR"])
eng = VerificationEngine(work_dir=str(run/"verify"))
for p in [run/"lists/raw.jsonl", run/"lists/high_accept.jsonl",
          run/"logs/invite.jsonl", run/"evidence/members.json"]:
    if p.exists():
        eng.checkpoint("t2_target", "complete", str(p))
        r = eng.verify_file(str(p)); print(p, r.status); assert r.ok, r
all_pass, report = eng.final_gate(required_outputs={
    "raw": str(run/"lists/raw.jsonl"),
    "high_accept": str(run/"lists/high_accept.jsonl"),
    "members": str(run/"evidence/members.json"),
})
assert all_pass, report
PY
VERIFY · SOCIAL + CODING (verification_engine) · FINAL GATE
VERIFY — T2 Target / scrape / groups / invite + coding gate
ROLE confirm: Moderator/Growth. VERIFY before start: ceilings + steps + corr_ids.

=== SOCIAL READ-AFTER-WRITE ===
1) Scrape file non-empty + schema valid (handle, url, accept_prob)
2) create_page/group → container_id + URL; get_container(id) live
3) invite rows: invite_id|status; re-fetch membership sample
4) No invites below accept threshold; ceilings not exceeded
5) Acting account matches plan; audit complete
PASS: verified container + invite outcomes + evidence
FAIL: empty scrape as success · invite without IDs · ceiling breach
INCONCLUSIVE: UI missing · captcha · rate wall — stop
N=3 backoff; escalate. No silent success.
Hard: no like/delete comments. EXECUTE for create/invite.

=== CODING / FILE (verification_engine.py) ===
eng = VerificationEngine(work_dir=f"{RUN_DIR}/verify")
for path in [raw_jsonl, high_accept_jsonl, create_json, invite_jsonl, members_json]:
    eng.checkpoint("target_t2", "complete", path)
    r = eng.verify_file(path)
    if not r.ok:  # STOP · diagnose · fix · re-verify
        ...
all_pass, report = eng.final_gate(
  required_outputs={
    "raw": f"{RUN_DIR}/lists/raw.jsonl",
    "high_accept": f"{RUN_DIR}/lists/high_accept.jsonl",
    "members": f"{RUN_DIR}/evidence/members.json",
    "invite_log": f"{RUN_DIR}/logs/invite.jsonl",
  },
)
if not all_pass:  # cannot claim done
    ...
# Reconcile: intended invites log vs platform membership sample

=== ANTI-MUTATION ===
Never skip verify_file · never promote INCONCLUSIVE · never hardcode PASS ·
never skip final_gate · never modify verification_engine.py during run

TASK 3 · Comment growth · Influencer threads · Auto-respond (no likes / no deletes)

Comment on famous characters & influencers to attract followers; respond to comments. Never like comments. Never delete comments.

5 PILLARS + VERIFY (social · coding · final_gate)

Comment growth + thread respond (safe mode)

Task goal: targeted value comments on influencer posts → attract profile visits → respond to own-thread comments → verify comment IDs live.

Golden rules: never like · never delete · value-first comments · ceilings · re-fetch thread attachment · correct parent post

planned validated executed verifying verified / failed
STRICT: do NOT like comments · do NOT delete comments
METHODOLOGY
METHOD — Comment growth / respond
1. boot + session + shadowban canary (skip growth if L3).
2. Build influencer list (niche, activity, audience overlap).
3. Read post fully; draft value comment (insight/question/add-on) — no spam.
4. State planned→validated; EXECUTE required to post comment.
5. post_comment(parent_post_id) → comment_id; get_thread / re-fetch.
6. Confirm comment attached to correct parent under correct account.
7. On own posts: respond to new comments (reply only — no likes).
8. Never delete comments (yours or others). Never like comments.
9. Rate: playbook ceilings; Poisson rest; human scroll before/after.
10. Log each: intent, selector/URL, comment_id, evidence screenshot optional.
Anti-block: cold visit with referrer; no 429 tight-loop; fingerprint stable.
CODING GATE: after every file output → eng.checkpoint + eng.verify_file; videos → frames@25/50/75 + measure_av_drift; before done → eng.final_gate all_pass.
Anti-mutation: never skip verify, never INCONCLUSIVE→PASS, never edit verification_engine.py.
PROMPT
ROLE: You are Responder agent (scoped: draft_comment, post_comment, list_comments, reply_comment, get_comment).
RULES:
- Draft only until EXECUTE.
- Report: Action | Target URL | Timestamp | Status | comment_id.
- FORBIDDEN tools: like_comment, delete_comment. Never call them.
- Browser-first. smart_click only. boot first.

TASK:
A) Growth: comment on {N} influencer posts in {niche} with unique value comments.
B) Respond: reply to unanswered comments on our posts from last 24h.
C) Do not like. Do not delete. Do not mass-generic emojis.

VERIFY before start: parent URLs, draft texts, ceilings, corr_ids.
OUTPUT: runs/YYYY-MM-DD_comments_{account}/

CODING VERIFY (mandatory):
Use verification_engine.VerificationEngine. After every sub-task file: checkpoint + verify_file; if not result.ok STOP/fix/re-verify. Any video: capture_inspection_frames(0.25,0.50,0.75) + measure_av_drift. Before done: final_gate(...); only all_pass allows "done". Three-state only: PASS|FAIL|INCONCLUSIVE. Never hardcode PASS.
TIPS
TIPS
• Read the post; reference a specific detail (proves human).
• Early comments (first 30–60m) get more surface area.
• Avoid links in first comment on strict platforms.
• One account → one IP (Mode C) for multi-account safety.
• If comment fails silently, re-fetch thread — never assume success.
• Skip influencers who disable comments.
• Respond tone = brand voice; short > essay.
• Quarantine on checkpoint/shadowban — no ban-loop.
• Evidence: optional screenshot of live comment.
• corr_id: cmt-{account}-{yyyyMMddHHmm}-{n}
TOOLS
TOOLS
• influencer list builder / scrape
• draft_comment · post_comment · reply_comment
• get_comment · list_thread · list_own_post_comments
• RateGovernor · humanize delays · smart_click
• SessionHealth · shadowban canary · quarantine
• audit JSONL + evidence/

ROLE TOOLSET (responder)
draft_comment · post_comment · reply_comment · get_comment · log_action
FORBIDDEN: like_comment · delete_comment · ban · unhide · mass_emoji_spam

VERIFY TOOLS
• verification_engine.py / VerificationEngine
• eng.checkpoint · eng.verify_file · eng.capture_inspection_frames
• eng.measure_av_drift · eng.final_gate · qa_gate
• CheckResult three-state (PASS|FAIL|INCONCLUSIVE)
FORBIDDEN: hardcode PASS · skip final_gate · mutate verification_engine.py
CODE · CMD
export RUN_DIR="runs/$(date +%F)_comments_${ACCOUNT}"
mkdir -p "$RUN_DIR"/{evidence,logs}

python3 omni_cli.py boot
python3 omni_cli.py shadowban --account "$ACCOUNT" || exit 1

# draft batch (no post)
python3 omni_cli.py draft_comments --targets influencers.jsonl \
  --out "$RUN_DIR/logs/drafts.jsonl"

# EXECUTE path
python3 omni_cli.py comment --account "$ACCOUNT" --from "$RUN_DIR/logs/drafts.jsonl" \
  --max 15 --humanize --no-like --no-delete \
  --corr-id "cmt-${ACCOUNT}-$(date +%Y%m%d%H%M)" | tee "$RUN_DIR/logs/posted.jsonl"

# read-after-write per id
python3 omni_cli.py get_comment --comment-id "$COMMENT_ID" \
  --parent-post "$PARENT_ID" --out "$RUN_DIR/evidence/${COMMENT_ID}.json"

# respond on own posts
python3 omni_cli.py respond_comments --account "$ACCOUNT" --since 24h \
  --mode reply-only --no-like --no-delete | tee "$RUN_DIR/logs/respond.jsonl"

# --- verification_engine (mandatory) ---
python3 - <<'PY'
from verification_engine import VerificationEngine
from pathlib import Path
import os
run = Path(os.environ["RUN_DIR"])
eng = VerificationEngine(work_dir=str(run/"verify"))
for p in [run/"logs/drafts.jsonl", run/"logs/posted.jsonl", run/"logs/respond.jsonl"]:
    if p.exists():
        eng.checkpoint("t3_comments", "complete", str(p))
        r = eng.verify_file(str(p)); print(p, r.status); assert r.ok, r
all_pass, report = eng.final_gate(required_outputs={
    "posted": str(run/"logs/posted.jsonl"),
})
assert all_pass, report
PY
VERIFY · SOCIAL + CODING (verification_engine) · FINAL GATE
VERIFY — T3 Comments / replies + coding gate
ROLE confirm: Responder. VERIFY before start: parent URLs + drafts + ceilings.
FORBIDDEN tools: like_comment, delete_comment (any use = task FAIL).

=== SOCIAL READ-AFTER-WRITE ===
1) post_comment / reply → comment_id + status + timestamp + corr_id
2) get_comment / re-fetch thread: exists + attached to correct parent_post_id
3) Acting account correct; text matches draft (or logged rewrite)
4) Audit proves zero like_comment and zero delete_comment
5) Replies/DMs: delivery status + correct recipient/thread
   (platform "can't DM non-followers" quiet fail = FAIL not PASS)
PASS: live comment_id evidence + parent match + no forbidden actions
FAIL: missing id · wrong parent · like/delete attempted
INCONCLUSIVE: not visible yet / held — do not claim done
N=3 backoff; escalate. Never free-text success.

=== CODING / FILE (verification_engine.py) ===
eng = VerificationEngine(work_dir=f"{RUN_DIR}/verify")
for path in [drafts_jsonl, posted_jsonl, *comment_evidence_files]:
    eng.checkpoint("comments_t3", "complete", path)
    r = eng.verify_file(path)
    if not r.ok:  # STOP
        ...
all_pass, report = eng.final_gate(
  required_outputs={
    "drafts": f"{RUN_DIR}/logs/drafts.jsonl",
    "posted": f"{RUN_DIR}/logs/posted.jsonl",
    "respond": f"{RUN_DIR}/logs/respond.jsonl",
  },
)
if not all_pass:
    ...  # UNABLE to say done

=== ANTI-MUTATION ===
Do not skip verify_file · do not treat INCONCLUSIVE as PASS ·
do not catch engine exceptions and continue · do not hardcode PASS ·
do not remove verification · do not skip final_gate ·
do not modify verification_engine.py

TASK 4 · Viral · Overgrowth · Full AI social manager (agent-operated)

AI-agent runs the manager — not you. Monitors session, logs actions, re-logs via credentials when cookies change, detects & stores new cookies.

5 PILLARS + VERIFY (social · coding · final_gate)

AI full-manager loop (session + viral growth)

Task goal: agent loop: health → plan growth/publish → execute within ceilings → verify → sleep/rest → repeat; auto-heal cookies.

Golden rules: agent owns session · cookie rotate + credential re-login · incident L1–L3 · never infinite retry · dated logs always

planned validated executed verifying verified / failed
Agent automation only · human escalate after N fails · no likes/deletes
METHODOLOGY
METHOD — Viral / overgrowth / AI manager
1. boot() self-check → secrets scanner → ServerRouter (1 account : 1 IP).
2. Session monitor loop (every T min): cookies valid? localStorage? checkpoint?
3. If cookies changed/expired:
   a) try cookie inject refresh
   b) else credential re-login (browser) → detect new cookies → encrypt sessions/{account}.enc
   c) chmod 600; delete plaintext
4. Growth planner: PhasedGrowth caps if account <21d; virality≥60 for publish.
5. Execute allowed actions only (permission manifest per role).
6. Every action: corr_id · log · screenshot optional · verify tool.
7. Incident map: 301→L1 reduce · 308→L2 re-export cookies · 310→L3 halt 48h.
8. Shadowban canary; quarantine on fail — no ban-loop.
9. Rest windows Poisson; anti-block ceilings.
10. Daily reconcile: intended log vs platform state.
Agent, not human, runs the loop; human only for EXECUTE on irreversible publish if policy requires.
CODING GATE: after every file output → eng.checkpoint + eng.verify_file; videos → frames@25/50/75 + measure_av_drift; before done → eng.final_gate all_pass.
Anti-mutation: never skip verify, never INCONCLUSIVE→PASS, never edit verification_engine.py.
PROMPT
ROLE: You are Manager Orchestrator agent (coordinates poster/responder/scraper; owns session heal).
RULES:
- Operate continuously within playbook. Publish still requires EXECUTE unless policy auto-approve is set.
- Report each cycle: Action | URL | Timestamp | Status | IDs.
- On cookie drift: re-login, record new cookies encrypted, resume.
- No like_comment / delete_comment. Browser-first. smart_click.

TASK: Run full social manager for accounts {list}
- Monitor sessions + auto-heal cookies/credentials
- Schedule viral content path (prepublish→publish→first_60)
- Growth actions within PhasedGrowth + RateGovernor
- Incident L1–L3 handling
- Write cycle reports to dated folder

VERIFY before each cycle: health, quarantine, ceilings, checklist of skills covered.
OUTPUT: runs/YYYY-MM-DD_manager/

CODING VERIFY (mandatory):
Use verification_engine.VerificationEngine. After every sub-task file: checkpoint + verify_file; if not result.ok STOP/fix/re-verify. Any video: capture_inspection_frames(0.25,0.50,0.75) + measure_av_drift. Before done: final_gate(...); only all_pass allows "done". Three-state only: PASS|FAIL|INCONCLUSIVE. Never hardcode PASS.
TIPS
TIPS
• One account → one VPS IP forever (Mode C).
• Cookie inject BEFORE navigate; save AFTER success.
• SameSite Titlecase sanitize; never leave plaintext cookies.
• refresh_silently every ~45m on long engage sessions.
• Viral tricks: hooks, series, early engage, native formats — still verify publish.
• Prefer reduce (L1) over aggressive retry when blocked.
• Keep manager cycle short; long hangs → kill + INCONCLUSIVE.
• Separate roles: orchestrator must not use delete tools.
• Store session_health.json each cycle.
• corr_id: mgr-{cycle}-{yyyyMMddHHmm}
TOOLS
TOOLS
• boot / self-check
• SessionHealth · session_sync_keep_alive
• EncryptedCookieManager · CookieChain
• credential re-login (browser) · cookie rotate
• ServerRouter · HybridDispatcher
• PhasedGrowth · RateGovernor · NSRE
• PrePublish · publish · first_60_minutes
• shadowban canary · quarantine · incident L1–L3
• agent_monitor.db / audit JSONL

ORCHESTRATOR TOOLSET
health_check · re_login · rotate_cookies · plan_cycle · dispatch_role · halt
FORBIDDEN: like_comment · delete_comment · drop_quarantine without evidence

VERIFY TOOLS
• verification_engine.py / VerificationEngine
• eng.checkpoint · eng.verify_file · eng.capture_inspection_frames
• eng.measure_av_drift · eng.final_gate · qa_gate
• CheckResult three-state (PASS|FAIL|INCONCLUSIVE)
FORBIDDEN: hardcode PASS · skip final_gate · mutate verification_engine.py
CODE · CMD
export RUN_DIR="runs/$(date +%F)_manager"
mkdir -p "$RUN_DIR"/{logs,evidence,sessions}

python3 omni_cli.py boot | tee "$RUN_DIR/logs/boot.json"

# continuous manager (agent loop)
python3 omni_cli.py manager --accounts accounts.yaml \
  --cycle-min 45 \
  --auto-relogin \
  --cookie-dir sessions \
  --encrypt \
  --incident-map \
  --out "$RUN_DIR" | tee "$RUN_DIR/logs/manager.jsonl"

# one-shot session heal
python3 session_sync_keep_alive.py --account "$ACCOUNT" --save-enc
python3 local_auto_login.py --account "$ACCOUNT" --if-expired --export-cookies

# canary + quarantine
python3 omni_cli.py shadowban --account "$ACCOUNT"
python3 omni_cli.py quarantine --account "$ACCOUNT" --reason L3 --hours 48

# reconcile intended vs actual
python3 omni_cli.py reconcile --log "$RUN_DIR/logs/manager.jsonl" \
  --out "$RUN_DIR/evidence/reconcile.json"

# --- verification_engine (mandatory each cycle / end) ---
python3 - <<'PY'
from verification_engine import VerificationEngine
from pathlib import Path
import os
run = Path(os.environ["RUN_DIR"])
eng = VerificationEngine(work_dir=str(run/"verify"))
for p in [run/"logs/boot.json", run/"logs/manager.jsonl",
          run/"evidence/reconcile.json"]:
    if p.exists():
        eng.checkpoint("t4_manager", "complete", str(p))
        r = eng.verify_file(str(p)); print(p, r.status); assert r.ok, r
# if local viral video rendered:
# eng.capture_inspection_frames(str(video), str(run/"evidence/frames"), (0.25,0.50,0.75))
# eng.measure_av_drift(str(video))
all_pass, report = eng.final_gate(required_outputs={
    "boot": str(run/"logs/boot.json"),
    "manager": str(run/"logs/manager.jsonl"),
})
assert all_pass, report
PY
VERIFY · SOCIAL + CODING (verification_engine) · FINAL GATE
VERIFY — T4 AI manager / viral loop + coding gate
ROLE confirm: Manager Orchestrator. VERIFY each cycle: health + quarantine + ceilings.

=== SOCIAL / SESSION READ-AFTER-WRITE ===
1) Each cycle: session_health + action audit with corr_ids
2) Cookie heal: new .enc exists; inject works; follow-up action as same account
3) Publish/engage sub-actions each pass their own get_* re-fetch
4) Incident level recorded; L3 halt honored
5) Reconcile sample: intended log vs platform state (flag drift)
PASS: healthy session + verified sub-actions + no forbidden tools
FAIL: loop without logs · fake success · ignored quarantine
INCONCLUSIVE: captcha / unknown UI — stop loop, escalate
Never claim “manager fine” without evidence files.

=== CODING / FILE (verification_engine.py) ===
eng = VerificationEngine(work_dir=f"{RUN_DIR}/verify")
# After EVERY cycle artifact:
for path in cycle_outputs:  # boot.json, session_health, manager.jsonl, reconcile.json
    eng.checkpoint("manager_t4", "complete", path)
    r = eng.verify_file(path)
    if not r.ok:  # STOP cycle · self-heal max 3 · re-verify
        ...
# Local video renders used for viral posts:
if video_path:
    eng.capture_inspection_frames(video_path, f"{RUN_DIR}/evidence/frames", (0.25,0.50,0.75))
    d = eng.measure_av_drift(video_path)
    if not d.ok:  # re-render apad + -shortest
        ...
all_pass, report = eng.final_gate(
  required_outputs={
    "boot": f"{RUN_DIR}/logs/boot.json",
    "manager": f"{RUN_DIR}/logs/manager.jsonl",
    "reconcile": f"{RUN_DIR}/evidence/reconcile.json",
    "session": f"{RUN_DIR}/logs/session_health.json",
  },
)
if not all_pass:  # UNABLE to say done
    ...

=== ANTI-MUTATION ===
Skip verify_file · INCONCLUSIVE→PASS · catch engine · hardcode PASS ·
comment out checks · max_attempts 0/1 · duration_tolerance>5 · skip final_gate ·
done with any fail · edit verification_engine.py — ALL FORBIDDEN

TASK 5 · Cookies · Auto-login · Messages · Invites · Account monitor · QA

Monitor cookies; auto-login with cookies or credentials; record updated cookies; respond to messages; invite people; monitor accounts; quality-assure social actions.

5 PILLARS + VERIFY (social · coding · final_gate)

Session ops · DM/invite · QA gate

Task goal: keep sessions live · rotate/record cookies · process DMs/invites under ceilings · QA every social action to PASS only.

Golden rules: encrypt cookies · inject before nav · save after success · QA = read-after-write · three-state never promote INCONCLUSIVE

planned validated executed verifying verified / failed
NO delete comments · NO like comments · QA blocks done until PASS
METHODOLOGY
METHOD — Cookies / auto-login / DM / invite / monitor / QA
1. boot + inventory accounts + cookie files (.enc).
2. For each account: health probe (navigate home with inject).
3. If fail: credential login → capture cookies → sanitize SameSite → encrypt → chmod 600.
4. Monitor cookie mtime/hash; on change, re-validate session.
5. DMs: list threads → draft replies → EXECUTE → confirm delivery + recipient.
6. Invites: only high-accept; ceilings; verify membership sample.
7. Account monitor: posts reach, login challenges, shadowban canary.
8. QA every action: structured return + re-fetch + audit.
9. Incident L1 reduce · L2 re-export cookies · L3 halt 48h.
10. Dated folder: session_health · cookies_meta (no secrets in logs) · qa_report.
Anti-block + humanize on every browser step.
CODING GATE: after every file output → eng.checkpoint + eng.verify_file; videos → frames@25/50/75 + measure_av_drift; before done → eng.final_gate all_pass.
Anti-mutation: never skip verify, never INCONCLUSIVE→PASS, never edit verification_engine.py.
PROMPT
ROLE: You are Ops/QA agent (scoped: session, cookies, dm_reply, invite, health, qa_gate).
RULES:
- Never print raw cookie values in reports — store encrypted only.
- EXECUTE required for DM send / invite.
- Report: Action | Target URL | Timestamp | Status | id.
- No like_comment / delete_comment.
- final_gate: all_pass required before done.

TASK:
1) Monitor cookies for {accounts}; re-login if invalid; record updated cookies encrypted.
2) Respond to unread messages (correct thread).
3) Process approved invite list (high-accept).
4) QA last N social actions from audit log (reconcile).
5) Write qa_report.json with PASS/FAIL/INCONCLUSIVE per action.

VERIFY before start: account list, cookie paths, ceilings.
OUTPUT: runs/YYYY-MM-DD_ops_qa/

CODING VERIFY (mandatory):
Use verification_engine.VerificationEngine. After every sub-task file: checkpoint + verify_file; if not result.ok STOP/fix/re-verify. Any video: capture_inspection_frames(0.25,0.50,0.75) + measure_av_drift. Before done: final_gate(...); only all_pass allows "done". Three-state only: PASS|FAIL|INCONCLUSIVE. Never hardcode PASS.
TIPS
TIPS
• Inject cookies before first navigate — order matters.
• After login success, always save; then delete any plaintext export.
• DM non-followers may fail quietly — treat as FAIL with platform rule note.
• QA is a separate read tool, not the write response.
• Keep secrets out of git and chat logs.
• Screenshot on checkpoint pages for human escalate.
• Rotate rest if multiple accounts on same host (prefer Mode C isolation).
• Permission manifest: ops may not publish unless also granted poster role.
• corr_id: ops-{account}-{yyyyMMddHHmm}-{n}
• Promote only PASS; INCONCLUSIVE blocks done.
TOOLS
TOOLS
• EncryptedCookieManager · cookie rotate · hash/mtime watch
• local_auto_login.py · session_sync_keep_alive.py
• SessionHealth · shadowban · quarantine
• list_dms · send_dm · get_dm_thread
• invite · get_membership
• qa_gate / final_gate · reconcile
• RateGovernor · humanize · smart_click
• audit JSONL (no secret values)

OPS TOOLSET
health · re_login · rotate_cookies · dm_reply · invite · qa · log
FORBIDDEN: like_comment · delete_comment · dump_plaintext_cookies · unscoped publish

VERIFY TOOLS
• verification_engine.py / VerificationEngine
• eng.checkpoint · eng.verify_file · eng.capture_inspection_frames
• eng.measure_av_drift · eng.final_gate · qa_gate
• CheckResult three-state (PASS|FAIL|INCONCLUSIVE)
FORBIDDEN: hardcode PASS · skip final_gate · mutate verification_engine.py
CODE · CMD
export RUN_DIR="runs/$(date +%F)_ops_qa"
mkdir -p "$RUN_DIR"/{logs,evidence,sessions}

python3 omni_cli.py boot
python3 omni_cli.py session_health --all --out "$RUN_DIR/logs/session_health.json"

# cookie monitor + heal
python3 session_sync_keep_alive.py --all --encrypt --dir sessions
python3 local_auto_login.py --account "$ACCOUNT" --if-invalid --export-enc \
  --out-meta "$RUN_DIR/logs/cookie_meta.json"

# DMs
python3 omni_cli.py dms --account "$ACCOUNT" --unread \
  --out "$RUN_DIR/logs/dms.jsonl"
# send only with EXECUTE
python3 omni_cli.py dm_reply --account "$ACCOUNT" --thread "$THREAD" \
  --text-file reply.txt --corr-id "ops-${ACCOUNT}-dm-1" | tee "$RUN_DIR/logs/dm_send.json"
python3 omni_cli.py get_dm_thread --thread "$THREAD" --out "$RUN_DIR/evidence/dm_verify.json"

# invites + QA
python3 omni_cli.py invite --from high_accept.jsonl --max 10 --humanize
python3 omni_cli.py qa_gate --audit "$RUN_DIR/logs" --out "$RUN_DIR/evidence/qa_report.json"
python3 omni_cli.py final_gate --require all_pass --report "$RUN_DIR/evidence/qa_report.json"

# --- verification_engine + final_gate (mandatory) ---
python3 - <<'PY'
from verification_engine import VerificationEngine
from pathlib import Path
import os
run = Path(os.environ["RUN_DIR"])
eng = VerificationEngine(work_dir=str(run/"verify"))
for p in [run/"logs/session_health.json", run/"logs/cookie_meta.json",
          run/"evidence/qa_report.json"]:
    if p.exists():
        eng.checkpoint("t5_ops", "complete", str(p))
        r = eng.verify_file(str(p)); print(p, r.status); assert r.ok, r
all_pass, report = eng.final_gate(required_outputs={
    "session_health": str(run/"logs/session_health.json"),
    "qa_report": str(run/"evidence/qa_report.json"),
})
print("final_gate", all_pass)
assert all_pass, report
PY
VERIFY · SOCIAL + CODING (verification_engine) · FINAL GATE
VERIFY — T5 Cookies / DM / invite / QA + coding gate
ROLE confirm: Ops/QA. VERIFY before start: accounts + cookie paths + ceilings.
Never print raw cookie values. final_gate all_pass required before done.

=== SOCIAL / SESSION READ-AFTER-WRITE ===
1) Session health PASS after heal; cookie meta updated (no secret leakage)
2) DM: delivery status + correct thread/recipient via get_dm_thread
3) Invite: status ids + membership sample re-fetch
4) QA report: every action has verified outcome (no free-text-only success)
5) final_gate(all_pass==True) before claiming done
   Account/credentials used must match agent belief
PASS: health + verified DM/invite/actions + audit complete
FAIL: plaintext cookie leak · wrong recipient · skipped qa_gate
INCONCLUSIVE: checkpoint/captcha — escalate
States enforced. N=3 retries. No like/delete comments.

=== CODING / FILE (verification_engine.py) ===
eng = VerificationEngine(work_dir=f"{RUN_DIR}/verify")
for path in [session_health, cookie_meta, dms, dm_verify, qa_report]:
    eng.checkpoint("ops_qa_t5", "complete", path)
    r = eng.verify_file(path)
    if not r.ok:  # STOP · fix · re-verify
        ...
all_pass, report = eng.final_gate(
  required_outputs={
    "session_health": f"{RUN_DIR}/logs/session_health.json",
    "cookie_meta": f"{RUN_DIR}/logs/cookie_meta.json",
    "qa_report": f"{RUN_DIR}/evidence/qa_report.json",
    "dm_verify": f"{RUN_DIR}/evidence/dm_verify.json",
  },
)
if not all_pass:
    ...  # UNABLE to say done — fix every non-PASS

=== ANTI-MUTATION ===
Do NOT skip verify_file · treat INCONCLUSIVE as PASS · catch engine exceptions ·
hardcode PASS · remove checks · weaken max_attempts/tolerance · skip final_gate ·
report done with any CheckResult.ok False · modify verification_engine.py

PLATFORMS SETTINGS · Video retention · SEO · Overgrowth

Best account/post settings per network, distilled from app sources: Social Media Mastery Guide.md · social media overgrowth.md · Advanced media overgrowth.md · SEVEN-ULTIMATE-MEDIA-MANAGER-UNIFIED.md · Lead generation and media automation.md (+ Hybrid/FULL-MERGED pipeline norms on this site).

Universal · High-retention video blueprint (all short-form)

Target >80–100% APV on short-form · cut any second where the retention graph dips · hub-and-spoke: 1 lead platform 30–60 days before expanding.

RETENTION BLUEPRINT
• 0.0–0.5s: motion + on-screen text + high-stakes verbal line
  (never “Hey guys…” / logo intros)
• Triple-hook: visual interrupt + text + spoken claim
• Every 2–3s: visual change (angle, punch-in 10–15%, B-roll, caption pop)
• Mid (~50%): second hook (“But here’s the REAL secret…”)
• 1.1–1.2× speech · silence removal · J-cuts 0.2–0.5s
• Word-by-word captions (1–3 words, highlighted)
• End loop / “Part 2 / follow” in last 1–2s
• After upload: open retention graph → cut dip seconds
MEDIA DEFAULTS (social H.264)
• Vertical short: 1080×1920 · 30fps · -framerate 30 on stills
• Audio out: -ar 48000 · apad + -shortest (A/V drift <0.5s)
• Loudnorm target social: I=-14:LRA=11:TP=-1 when mastering
UNIVERSAL SEO / CAPTIONS
• Hook formula: Curiosity gap + Emotional trigger + Clear benefit
• Spoken keywords + on-screen text + caption keywords (tri-layer SEO)
• Platform-native versions > pure cross-post (~40% better)
• Repurpose: 1 long → 8–12 shorts → 4–6 carousels → 2–3 threads
• Avoid hashtag stuffing; prefer 3–5 hyper-relevant (+ niche)
• Strip GPT-isms: delve, tapestry, unlock, landscape, elevate…
• Unique titles / used_titles check before publish
• First-hour engage is part of SEO signal (replies, not likes spam)
• Verify publish with post_id + re-fetch (moderation hold = fail)
UNIVERSAL OVERGROWTH
• Lead platform 30–60d (TT or IG Reels) then expand
• Warm_up scroll niche feed before any publish
• Virality gate ≥60 PrePublish; absolute media paths
• First-hour: reply hard; share to friends/groups when native
• PhasedGrowth caps if account <21 days
• Shadowban canary before heavy growth
• A/B hooks + thumbnails weekly; kill losers
• Series (“Part 1…”) + collab/stitch/duet for graph edges
• 90 days consistency beats burst-then-quit
• Anti-block: ceilings, rest windows, 1 account : 1 IP (Mode C)
INSTAGRAM

Instagram · Reels · Carousels · Stories

Reels 3–7/wkCarousels 2–4/wkStories daily 1080×1920 · ≤90sFirst 30 min engage
ACCOUNT · POST SETTINGS
ACCOUNT / LIMITS (Mastery + SEVEN)
• posts_per_day: 3 · min_gap: 120 min
• comments_per_day: ~20 (warmup lower)
• Warmup week: ~20 actions/day max
• Mature: posts 3–5/d peak; comments 15–20; likes 80–100
• Sessions: encrypt cookies + local_storage (IG needs both)
• Mode C: 1 account → 1 VPS IP forever
• Headed publish preferred; absolute media path
• Collab posts weekly; Broadcast Channel for exclusives
• Stories: interactive stickers daily
• Checkpoint/captcha → STOP 24–48h (never auto-solve)

MEDIA SPECS
• Feed: 1080×1080 (or 4:5 1080×1350)
• Reels: 1080×1920 · H.264 · ≤90s (prefer 7–30s growth)
• Cover/thumbnail readable at small size
VIDEO · RETENTION
RETENTION (Reels)
• Hook 0–3s or die: pattern interrupt, text overlay, motion
• Trending audio within 24h of rising (Trending tab)
• 3-second visual loop at end → rewatch = APV boost
• Visual change every 2–3s; punch-in 10–15%
• Word-by-word captions; 1.1–1.2× speech optional
• Mid-roll hook ~50% to prevent drop-off
• Design for DM shares (save-worthy value)
• Carousels: slide 1 hook → pure value → CTA follow/part 2
  (highest saves format)
• After post: watch retention in Insights; cut future dips

QA if local render: frames 25/50/75 + A/V drift check
SEO · HASHTAGS · CAPTION
SEO / CAPTION
• First line hook ≤125 chars; force “Read more…”
• Clean caption body; put 10–15 tags in FIRST COMMENT
  (or 3 niche + 2 broad + 1 branded)
• Hashtag health: 5–15 relevant; never >30 spam
• Alt text on images; keyword in early caption
• Hidden story tags (tiny text) only as light boost — don’t rely
• Avoid banned/overused pure-viral tags alone
• Unique titles vs used_titles (P9)
• Keyword in on-screen text + spoken line

PrePublish: virality ≥60 before EXECUTE publish
OVERGROWTH
OVERGROWTH
• Lead with Reels 30–60d if this is primary
• First 30 min: reply every comment (no like spam)
• Explore path: trending audio + twist POV
• Collab feature weekly; reply to niche Stories
• ManyChat keyword DM (Meta-approved) for lead magnets
• 10-slide value carousels for saves
• Cross-post native versions to TT/Shorts/FB — different hooks
• Shadowban canary on tag chrono if reach collapses
• PhasedGrowth if account <21d
• A/B hooks weekly; series “Part 1…” for follows

VERIFY: post_id + permalink + get_post live
No delete comments · no like comments

Sources: Mastery rate tables · SEVEN § media paths · overgrowth IG · Lead-gen Reels/ManyChat

TIKTOK

TikTok · FYP · Series · Stitch/Duet

3–5/wk qualityor 3–5/d if APV holds 1080×1920First 60 min velocity7–30s viral · ≤60s authority
ACCOUNT · POST SETTINGS
ACCOUNT / LIMITS
• posts_per_day: 2 (safe) · min_gap: 180 min
• comments_per_day: ~10 warmup → 10–15 mature
• Warmup: conservative; never tight-loop
• Cookie + local_storage in .enc session
• Clear joyride/onboarding overlays before upload
• Headed preferred; abs media path
• Peak times (Egypt GMT+3): 7–9 PM weekdays; 11 AM–1 PM weekends
• Canary on tag page if no FYP push
• Quarantine on checkpoint — no ban-loop

MEDIA
• 1080×1920 · 30fps · H.264
• Prefer 7–30s pure virality; up to 60s authority
• Text overlay on first frame mandatory
VIDEO · RETENTION
RETENTION (FYP scores first ~3s hard)
• Motion + text + spoken hook in first 0.5–3s
• Trending sound within 24–72h of trend
• Mid-roll hook at ~50% completion
• Visual change every 2–3s; no dead air
• Word-by-word captions; high energy
• “Follow for Part 2” last 2 seconds
• Mildly polarizing take → comments (signal)
• Series structure builds follows
• Post-upload: retention graph → cut dips

Velocity: early comments/shares in first hour
push distribution — plan first_60_minutes
SEO · HASHTAGS · CAPTION
SEO
• 3–5 hashtags max (mix trending + niche)
  e.g. #DigitalMarketingTips not only #Viral
• Inline hashtags in caption (not dump wall)
• Spoken + on-screen + caption keywords
• Text on first frame = searchable surface
• Stitch/duet titles carry parent SEO
• Avoid spam hashtag packs that break discovery
• Unique description each post (no clone spam)

PrePublish virality ≥60 · unique title check
OVERGROWTH
OVERGROWTH
• Best zero-to-audience lead platform (w/ IG Reels)
• Study 10 niche virals last 30d → same hook structure,
  your face/voice (not stolen IP)
• Stitch/duet relevant creators
• First 30–60 min: reply all; share to 5 friends if natural
• Series “Part 1…” for follow loops
• Cross-native to Reels/Shorts with new hooks
• Shadowban: hashtags fail / For You dead → canary + L3 halt
• A/B hooks weekly; kill losers
• Target: 50K–100K+ views/month system (Advanced)

VERIFY: post_id + re-fetch live · no like/delete comments

Sources: Advanced FYP · overgrowth TT · SEVEN platform table · Mastery limits

YOUTUBE

YouTube · Shorts + Long-form funnel

Shorts 1–3/dayLong 1–2/wk Thumbnail+title = hookFirst 30s open loop
ACCOUNT · POST SETTINGS
ACCOUNT / LIMITS
• posts_per_day: 1 long-safe · Shorts higher volume
• comments_per_day: ~10 · first 2h reply critical
• Peak (GMT+3): 2–4 PM, 8–10 PM (watch time)
• Chapters + end screens + Community tab on
• Shorts → long: pin / description funnel
• Absolute media paths; verify duration before upload
• Session cookies encrypted; headed if browser path

MEDIA
• Shorts: 1080×1920 · 15–45s high completion
• Long: 1920×1080 (or 4K) · chapters every topic shift
• Thumb: high-contrast + face emotion
• Audio 48kHz; loudnorm social/broadcast as needed
VIDEO · RETENTION
RETENTION
• Thumbnail + title are the real hook (CTR)
• First 30s: open loop, zero filler / no long intros
• Chapters = retention + algorithm signal
• Pattern: payoff breadcrumbs every 30–60s
• Shorts: high completion; loop-friendly end
• Long: <30% drop in first minute target
• End screen: Subscribe + suggested video
• After publish: retention graph → cut dead air

Local render QA:
capture_inspection_frames 25/50/75
measure_av_drift · final_gate before claim done
SEO · HASHTAGS · CAPTION
SEO
• Title: keyword front + curiosity (not pure clickbait)
• Description: first 150 chars keyword-rich + links
• 3–5 hashtags in description (search + suggest)
• Upload transcript / accurate captions (YT reads them)
• Chapters with keyword labels
• Tags: primary + related (not stuffing)
• Custom thumb text large & readable mobile
• Shorts description links long-form
• Consistent series naming for suggest graph

Unique titles; no duplicate spam uploads
OVERGROWTH
OVERGROWTH
• Shorts as discovery → long-form authority
• Community posts between uploads
• Reply comments first 2 hours hard
• Collab / guest / mention networks
• A/B thumbnails (face vs text) weekly
• Suggested-video packaging (end screens)
• Target system: 1K–5K+ subs / 30 days aggressive
  only with retention + CTR discipline
• Repurpose long → 8–12 Shorts native hooks
• Lead gen: commenters of competitor videos

VERIFY: video_id + public URL + not processing forever
final_gate on local masters before upload

Sources: Advanced YT · overgrowth Shorts/long · SEVEN · verification video gate

TWITTER / X

X · Threads · Velocity · Replies

Up to 5–8 posts/day matureFirst 15 min engage ≤280 · ≤2 tags mainThreads for authority
ACCOUNT · POST SETTINGS
ACCOUNT / LIMITS (Mastery + SEVEN)
• posts_per_day: 8 mature · min_gap: 30 min
• Stealth warmup: ~15 tweets/day
• comments/replies: 30/day mature; 50–100 peak careful
• First 15 min engagement window
• Trim captions ~270 for safety buffer
• Cookie sessions .enc; Mode C IP sticky
• Never 429 tight-loop — backoff + rest

MEDIA
• Images 1200×675 or 1080×1080
• Video: short native clips; captions burned or alt
• Single link posts often suppressed — put link in reply
VIDEO · RETENTION
ATTENTION (text + short video)
• Hook in first line (curiosity + number)
• Thread: tweet 1 open loop; 2–N value; end CTA
• Short video: first 1–2s motion + text
• Keep clips tight; autoplay silent → captions on
• Quote-tweet with added insight (not empty RT)
• Polls / questions for reply velocity
• Cut filler; mobile-first line breaks

Retention graph less central than reply velocity
in first 15 minutes — plan reply burst
SEO · HASHTAGS · CAPTION
SEO / DISCOVERY
• ≤2 hashtags in main post (often 0–1 better)
• Keywords in plain language (search + Grok/X search)
• Thread titles with specific numbers =
  credibility (“I spent $50k on Meta ads…”)
• Alt text on images
• Don’t hashtag-stuff; looks spam → shadow risk
• Pin high-performing thread
• Bio keywords for profile SEO
• Unique posts; avoid clone spam across accounts
OVERGROWTH
OVERGROWTH
• Reply to influencers fast (value replies, not “great post”)
• First 15 min: self-reply value + engage quote graph
• Threads 2–4×/week for authority
• Lists + Spaces when relevant
• Cross-promote IG/YT with native wording
• Shadowban canary: tag/search visibility
• Bio email scrape is research-only; publish ethically
• Warmup caps if new account
• Never like/delete comment spam patterns

VERIFY: tweet_id + URL + re-fetch; account match
EXECUTE required for live posts

Sources: Mastery X limits · SEVEN 280/≤2 tags · Lead-gen threads · overgrowth

FACEBOOK

Facebook · Reels · Groups · Live

Reels 1–2/dayGroups value-first Lives 10+ minProfile often > Page organic
ACCOUNT · POST SETTINGS
ACCOUNT / LIMITS
• posts_per_day: 3 · min_gap: 90 min
• comments_per_day: ~15 · mature 20–30
• Peak (GMT+3): 1–3 PM, 7–9 PM (groups active)
• Harsh automation detection — fingerprint + cookie hygiene
• Never auto-solve checkpoints; halt 24–48h
• Native upload > external link posts for reach
• Page vs Profile: test; profile often stronger organic
• Groups: join 10+ niche; value before promo

MEDIA
• Reels 1080×1920 native
• Live ≥10 min preferred by ranking
• Repurpose Live → Reel/Short after
VIDEO · RETENTION
RETENTION
• Native Reels: same short-form blueprint
  (0.5s motion hook, captions, mid-hook)
• Meaningful interactions > passive views
  (comments, shares, long watches)
• Live: talk to chat; ask questions; 10+ min
• Cut logos/intros; start with conflict/result
• Group videos: speak to group identity
• After Live: export highlight Reel same day

A/V: 48kHz · apad+-shortest on local masters
SEO · HASHTAGS · CAPTION
SEO / COPY
• Conversational captions that invite comments
• 1–3 hashtags max if any (FB weaker on tags)
• Keyword in first line + on-screen text
• Group post SEO = group topic keywords
• Avoid external link in first comment only when
  needed; native first for distribution
• ALT text on images
• Clear CTA: question end-line for replies
• Unique copy per group (no spam clone)
OVERGROWTH
OVERGROWTH
• Meaningful Interactions hack: niche groups
• Share value posts to 5+ niche groups (not spam)
• Own group for recurring discussion hub
• Go Live periodically; repurpose as Reel
• Collab with admins (permission + value)
• Profile organic test vs Page
• Cross from IG/TT native re-edits
• Incident: FB harsh on automation — ceilings strict
• Lead: webinar/event networking → FB groups

VERIFY: post/group id + re-fetch; no like/delete comments
Invite only high-accept (see Task 2)

Sources: Advanced FB groups/live · overgrowth FB · Mastery detection notes · SEVEN

LINKEDIN

LinkedIn · Carousel · Document · Dwell

1–2/day weekdaysDocument/carousel 20–30 meaningful comments/dayProfessional tone
ACCOUNT · POST SETTINGS
ACCOUNT / LIMITS (Mastery)
• posts: 3–5/wk safe → 1–2/day weekdays mature
• comments: 30–50/day careful; quality > spray
• min gaps generous; human dwell on feed first
• Peak professional hours (local business AM)
• Guest posting / collab features when available
• Session cookies .enc; no aggressive scrapers on UI
• Sales Nav research separate from publish identity

MEDIA
• Document PDF carousel (high dwell)
• Native video square/vertical acceptable
• Images with large text for mobile
VIDEO · RETENTION / DWELL
RETENTION / DWELL
• Document posts maximize dwell (algorithm loves)
• Hook line 1; line break “see more”
• Carousel: hook slide → frameworks → CTA
• Video: professional hook ≤3s; captions on (mute)
• Storytelling: struggle → lesson → tactical steps
• End with open question (comment bait, not spam)
• Soft CTA; avoid hard sell every post

Read-time > pure views on LinkedIn
SEO · HASHTAGS · CAPTION
SEO
• Professional tone; industry keywords early
• 3–5 hashtags max at end (niche + industry)
• Open question at end of caption
• Document title = searchable topic
• Profile headline/about = primary SEO surface
• Tag people sparingly and relevantly
• No emoji walls; clean formatting
• Alt text; accessible language
• Unique insight > recycled viral fluff
OVERGROWTH
OVERGROWTH (B2B)
• 20–30 meaningful comments/day on ICP posts
• Document/carousel 3–5×/week
• Guest/collab posts for graph edges
• Intent signals → personalized outreach
  (Apollo/Hunter free tiers — research)
• Webinar attendance → post-event connects
• SEO content + lead magnet compound 3–6 mo
• Hub: LinkedIn posts → email list
• Never spam invites; high-accept only
• Warmup if new: lower comment volume

VERIFY: post_urn/id + re-fetch · role=poster/responder split
No like/delete comment abuse

Sources: Mastery LinkedIn · SEVEN table · Lead-gen LI · overgrowth carousels

Posting windows · rate ceilings · first-hour (quick table)

PLATFORM QUICK TABLE (from Mastery + Advanced + SEVEN + overgrowth)
Platform   | Cadence (mature)     | First-hour focus | Media default        | Hashtags        | Peak (Egypt GMT+3)
-----------|----------------------|------------------|----------------------|-----------------|--------------------
Instagram  | Reels 3–7/wk + car.  | First 30 min     | 1080×1920 reel ≤90s  | 10–15 1st cmt   | 9–11 AM, 7–9 PM
TikTok     | 3–5/wk (or daily*)   | First 60 min     | 1080×1920 7–30s      | 3–5 inline      | 7–9 PM; 11–1 wknd
YouTube    | Shorts 1–3/d + long  | First 2h comments| Shorts 15–45s + 16:9 | 3–5 in desc     | 2–4 PM, 8–10 PM
X/Twitter  | 5–8 posts/day        | First 15 min     | ≤280 · ≤2 tags       | 0–2             | frequent bursts
Facebook   | Reels 1–2/d + groups | Group replies    | Native Reels/Live    | 0–3             | 1–3 PM, 7–9 PM
LinkedIn   | 1–2/day weekdays     | Dwell + comments | Document/carousel    | 3–5 end         | business AM/mid

*Daily TT only if retention/APV holds — quality > spam volume.
Warmup: use Mastery lower bounds (IG ~20 actions/day stealth, X ~15 tweets/day).
Always: boot → warm_up → PrePublish≥60 → EXECUTE → capture URL → verify get_* → first_hour.
Verify coding outputs with verification_engine final_gate when rendering media locally.
Copied