Update to Kabo

{
  "description": "Turn a creator's account review, trend or competitor research, a video analysis, a video's YouTube or TikTok comments, or an explicit topic into distinct content ideas the creator can compare and choose from. Use when a creator asks what to make next, wants a first batch of topics for a new account, wants ideas that fit a time or equipment budget, wants follow-up ideas from a video's comments, or wants new hooks for a weak topic. Not for diagnosing an account or planning a posting calendar.",
  "included_files": [
    {
      "relative_path": "references/comment-evidence.md",
      "size_in_bytes": 8323
    },
    {
      "relative_path": "references/core-generation.md",
      "size_in_bytes": 4192
    },
    {
      "relative_path": "references/evidence-acquisition.md",
      "size_in_bytes": 7129
    },
    {
      "relative_path": "references/idea-request.schema.json",
      "size_in_bytes": 11199
    },
    {
      "relative_path": "references/idea-set-rules.md",
      "size_in_bytes": 4006
    },
    {
      "relative_path": "references/idea-set.schema.json",
      "size_in_bytes": 17501
    },
    {
      "relative_path": "references/report-language.md",
      "size_in_bytes": 3078
    },
    {
      "relative_path": "references/report-locales.json",
      "size_in_bytes": 15139
    },
    {
      "relative_path": "references/selected-idea.schema.json",
      "size_in_bytes": 3747
    },
    {
      "relative_path": "scripts/build_idea_request.py",
      "size_in_bytes": 12118
    },
    {
      "relative_path": "scripts/persist_envelope.py",
      "size_in_bytes": 40967
    },
    {
      "relative_path": "scripts/project_account_context.py",
      "size_in_bytes": 11138
    },
    {
      "relative_path": "scripts/project_comments.py",
      "size_in_bytes": 11258
    },
    {
      "relative_path": "scripts/render_idea_report.py",
      "size_in_bytes": 21904
    },
    {
      "relative_path": "scripts/report_language.py",
      "size_in_bytes": 7546
    },
    {
      "relative_path": "scripts/run_ideas_stages.py",
      "size_in_bytes": 20604
    },
    {
      "relative_path": "scripts/static_host.py",
      "size_in_bytes": 33121
    },
    {
      "relative_path": "scripts/validate_ideas.py",
      "size_in_bytes": 62139
    }
  ],
  "name": "develop-content-ideas",
  "skill_md_contents": "---\nname: develop-content-ideas\ndescription: \"Turn a creator's account review, trend or competitor research, a video analysis, a video's YouTube or TikTok comments, or an explicit topic into distinct content ideas the creator can compare and choose from. Use when a creator asks what to make next, wants a first batch of topics for a new account, wants ideas that fit a time or equipment budget, wants follow-up ideas from a video's comments, or wants new hooks for a weak topic. Not for diagnosing an account or planning a posting calendar.\"\ncompatibility: \"Requires Python 3 and read and write access to a local workspace. Fetching a video's comments also requires the Kabo MCP server at https://kabo.sh/mcp-pub and a host that can save a tool's complete result to a file.\"\nallowed-tools: get_research_capabilities get_research_data_job get_research_data_download youtube_list_comments tiktok_discovery_list_comments tiktok_discovery_list_comment_replies\n---\n\n# Develop Content Ideas V3\n\nTurn validated upstream artifacts or an explicit topic into an IdeaSet of distinct, selectable\nideas. The schemas, builders, validators and renderers ship in this Skill's `references/` and\n`scripts/`. When the host supports one, run this Skill in a foreground sub-agent, because a run has\nseveral stages, and wait for its final result before replying; never run it in the background and\ntell the user the report will come later. Without a foreground sub-agent, follow the same steps in\nthe main thread.\n\nThis V3 runtime consumes upstream V3 artifacts through `upstream_sources[]` and deterministic\nsemantic `idea_context`. `user_brief.text` preserves the user's request; it is not by itself proof\nthat a usable topic exists. Do not parse Creator-facing Markdown, use removed\n`opportunities[]/opportunity_id`, use competitor outputs as hidden criteria, or search the web.\nNever infer a business domain or content topic from a handle, account/display name, URL, platform,\nor another Skill's description. Do not create a SelectedIdea until the creator explicitly chooses\nor edits an idea.\n\nBefore writing artifacts, read the fields and referenced definitions for this task intent in\n`references/idea-request.schema.json` and `references/idea-set.schema.json` together, and read\n`references/core-generation.md` (stage timing and the two-call core budget) whole before prep.\n\n## Set up one run\n\n`<skill directory>` is the folder holding this `SKILL.md`. Reserve exactly one run per request:\n\n```sh\npython3 '<skill directory>/scripts/static_host.py' init --workspace '<user-workspace>'\n```\n\nIt prints the run directory; below, `<run directory>` is that absolute path, and it is the\n`--run-dir .` the stage commands name. Many hosts keep neither environment variables nor the working\ndirectory between commands, so every command that needs the run starts with\n`cd '<run directory>' &&`, and the ones that read the run's staging area also set\n`KABO_STATIC_RUN_DIR='<run directory>'` inline, exactly as written below. `scripts/…` and\n`references/…` live in `<skill directory>`; call scripts by that absolute path. No step here\npauses and resumes, so no command takes `--placed`.\n\n- **Every command below is complete as written.** Do not run a script with `--help`, read its\n  source, or search other Skills. Use `grep`, not `rg`. Quote filesystem paths in commands.\n- Write `intent.json` and `idea_set.json` at the run root with a heredoc\n  (`cat > <run directory>/intent.json <<'JSON' … JSON`) or the host's file tool. Keep the timing\n  file and every upstream artifact in this run directory for the whole run; never invent another\n  run path or reset prep. One run serves one request: never reserve a second run for the same\n  request, and start a different request in a new run.\n- Make the model authorship and the one permitted revision between stage commands, never inside\n  one.\n- A failed or unavailable **tool call** is evidence, not the end of the run: record it and continue\n  as `references/comment-evidence.md` says. When `static_host.py fetch` or `stage` refuses a result\n  because it carries no connector evidence, because its job is still queued, or because it holds no\n  complete evidence object, that refusal means the tool call failed; it is not a script failure.\n  Read the tool's own message it prints and retry by error kind as `references/comment-evidence.md`\n  says. A nonzero exit from any other **script** ends the run (for core, see step 5): report it, and\n  never reopen the run, repeat completed prep, reset the generation budget or start a replacement\n  run. Do not write or claim a run-record status yourself; core succeeding does not make one.\n\n## Where evidence comes from\n\nThis Skill runs no research. Upstream evidence is the JSON output another Skill already wrote in\nthis workspace:\n\n| Evidence | Produced by | Prep flags |\n|---|---|---|\n| Account review and creator profile | `review-creator-account` (`account_review.json`, `creator_profile.json` in its report directory) | `--account-review`, `--creator-profile` |\n| Trend report and its Idea projection | `research-youtube-trends`, `research-instagram-trends`, `research-tiktok-trends` | `--trend-report` with `--trend-context` |\n| Competitor report and its Idea projection | `analyze-creator-competitors`, `analyze-tiktok-competitors` | `--competitor-report` with `--competitor-context` |\n| VideoAnalysis | `analyze-content-video` | `--video-analysis` |\n| A video's comments | fetched by this Skill (below) | `--comment-context` |\n\nCopy each upstream JSON file into this run directory unchanged (`cp`) and pass the copy. A trend\nor competitor report counts only together with its `*_idea_context.json` projection; when the\nprojection is missing, treat that source as missing and name the producing Skill and its Idea\nprojection step as the next step. Never write a projection by hand. Every\nartifact flag takes the JSON artifact, never its Markdown report (`account_review.json`, not\n`ACCOUNT_REVIEW.md`). A report summary, a description of an earlier reply or model-retyped JSON is\nnot a replacement for the original file; if the original is no longer available, follow the\nmissing-source decision rather than inventing account context. Restored inputs remain reused evidence with their original\nlimits; they do not imply a new account fetch or deep-viewing projection. The deep account review\nwrites no Idea projection; use the standard review it extended. When a required artifact is not in\nthe workspace, read `references/evidence-acquisition.md` whole: it says which claims need which\nevidence and how to name the Skill that produces it. Skip it when supplied evidence or the explicit\nbrief already satisfies the request. Never ask the creator to transcribe public\ndata or copy results; follow the prep decision below.\n\n**Comments.** For ideas based on a video's comments, this Skill fetches them itself with the\ntools in `allowed-tools`. Read `references/comment-evidence.md` whole before the first call: it\nholds the calls, the commands that save, fetch and persist each complete result, and the\nprojection.\n\n## Prep\n\nSplit every run into **prep** and **core**; do not move idea authorship or revision into prep to\nevade the core budget. `build_idea_request.py` derives `source_mode` from the actual supplied\nartifacts and projections; leave it out of the intent. Trend/competitor context alone becomes\n`context_only`, and missing evidence never becomes `evidence_rich`. Required-source gates and\nlineage validation still apply. Collection failure does not authorize brief fallback.\n\n1. Determine the request's `task_intent` and preserve the exact requested Idea/Hook count and\n   original user wording in `user_brief` when present. If the user asks for ideas but does not\n   specify a Hook count, set `hook_option_count` to `1` (one opening per idea); never emit `0` for\n   a generative shortlist. Choose between `open_shortlist`, `capacity_plan`, `rework_content` and\n   `brief_only` as *Choosing task_intent* in `references/idea-set-rules.md` says.\n2. Fill `generation_basis` before synthesis:\n   - `direct_topic` is a literal content-topic phrase the user supplied. A handle, account/display\n     name, URL, platform, format, or generic request for ideas is not a topic. Never derive it from\n     another Skill's description, the environment, or model knowledge.\n   - `required_sources` lists evidence the user explicitly requires: `creator`, `account`,\n     `trend`, `competitor`, `video`, or `comments`. A request about comments on a video requires\n     `comments`; it does not also require `video` unless the Creator asks to analyze the clip\n     itself.\n   - `allow_brief_fallback` defaults to `false`; set it to `true` only when the user explicitly\n     permits using `direct_topic` if required evidence is missing. When you set it, copy the part\n     of `user_brief.text` that gave the permission into `brief_fallback_quote`, word for word and\n     in the user's own language: the check is that the span is really in the brief, not that it is\n     worded any particular way. Do not paraphrase it, and do not set the flag on a brief that does\n     not say this.\n3. Validate each native upstream artifact before synthesis: sparse `creator-profile.v3`,\n   `account-idea-context.v1`, `trend-research-report.v3`, `competitor-research-report.v3`, and\n   optional VideoAnalysis. Consume only the deterministic `idea_context.creator/trend/competitor/account`\n   projection the upstream Skills write.\n4. Write `intent.json` with all required request fields except `upstream_sources` and\n   `idea_context`. Never put either field in `intent.json`, even empty: prep builds both from the\n   artifact flags and rejects an intent that carries them. Include\n   `schema_version=\"idea-request.v3-candidate2\"`, a run-local unique `request_id`, ISO-8601\n   `created_at`, `task_intent`, counts, goal, audience, desired action, platforms, languages,\n   `report_language`, `user_brief`, `generation_basis`, production constraints and exclusions; the\n   builder does not invent missing metadata. Then run one prep command that builds, validates, and\n   decides without further model branching:\n\n   ```sh\n   cd '<run directory>' && python3 '<skill directory>/scripts/run_ideas_stages.py' prep --intent intent.json --run-dir .\n   ```\n\n   Add the artifact flags this run has: `--creator-profile`, `--account-review`, `--trend-report`\n   with `--trend-context`, `--competitor-report` with `--competitor-context`, `--video-analysis`,\n   or `--comment-context`. Account evidence reaches prep as `--account-review <copied\n   account_review.json>` alone: prep projects that review into `account_idea_context.json` in this\n   run itself. Never write or edit an account context by hand; an `--account-context` that differs\n   from the review's projection is rejected. If a flag points at a non-JSON file, prep exits `0`\n   with `status=\"needs_correction\"`, lists the flag, path and JSON files beside it, and changes\n   nothing in the run: rerun the same prep in the same run with the JSON path. Prep writes\n   `request.json`, `decision.json`, and the prep section of `stage_timing.json`. Do not synthesize\n   before reading that decision.\n5. Obey the decision exactly:\n   - `blocked_missing_required_source`: write an empty IdeaSet, add every canonical `missing_required_source:<source>` reason, and set `interaction.next_actions` to include all of `blocked`, `refresh_evidence` and `provide_own_direction` (never `choose`). Then run core once to validate/render the empty block (this is not a creative generation success).\n   - `needs_selection_context`: write an empty IdeaSet with\n     `explicit_content_topic_or_upstream_evidence` in `selection_missing`; ask for a topic or\n     evidence. Clarification is not a completed idea-generation task.\n   - `ready_for_generation`: continue into Core. When `brief_fallback_used=true`, carry every\n     missing-source token into `evidence_summary.data_gaps` and do not claim the missing evidence\n     informed the ideas.\n   - An explicit niche plus a concrete deliverable is sufficient `direct_topic` for brief-only\n     generation when the user did not require external evidence. Do not ask the creator to choose\n     between a quick and broad research path after the deliverable is clear; choose the least\n     expensive valid path and deliver the requested candidates. If the user names an account,\n     trend, competitor, video, or comments as an input, preserve that requirement and use the\n     evidence path above or the missing-source block rather than asking them to select a research\n     mode.\n\n## Core\n\nCore starts only after prep reports `ready_for_generation` (prep opens `stage_timing.json`\ncore.started_at at that moment). The target is **at most two** model generation passes that write\nor revise `idea_set.json` (generate, then revise only if programmatic validation fails). Do not\ninvent extra critique/rewrite loops. Network, 5xx or host truncation retries are allowed and are\nrecorded with `cd '<run directory>' && python3 '<skill directory>/scripts/run_ideas_stages.py' core\n--run-dir . --record-network-retry \"<note>\"` (this does not consume a generation attempt).\n\n1. Apply explicit production constraints. Record only assets the user supplied or evidence shows\n   are available.\n2. In **one** generation pass, write the complete `idea_set.json`: distinct titles the Creator could publish, hooks, making direction, evidence basis, ranking, gates, and limitations. Remove near-duplicates and rank by Creator fit, evidence strength, differentiation, timeliness, and realistic production cost. A plain question or statement is sufficient for a title; keep teaching method detail in `making_direction`. Never invent loss amounts, customer outcomes, efficiency gains, market facts, policy facts, numbers, or URLs. Preserve artifact-level lineage in `upstream_sources`, context-level refs in `source_context_refs`, `must_avoid` as `must_differ`, and risk language. `required_assets` must be a subset of the request's declared `available_assets`; when the user supplied no assets, leave both `required_assets` and `assets_used` empty and put possible future props in `assumptions` or `production_missing`. Do not edit, patch, or replace the skill scripts, schemas, or validators; fix a rejected IdeaSet by revising only `idea_set.json` once.\n3. Put missing information into `gates.selection_missing` only when it prevents a valid choice.\n   Put filming, editing, CTA, cadence, or other later details into `gates.production_missing`;\n   these may coexist with `ready_for_selection`. If `production_missing` is nonempty, include\n   `answer_production_question` in `interaction.next_actions` alongside the selection action; do\n   not make later production details block topic selection.\n4. Run the core stage (validate → render, or emit a revision brief):\n\n   ```sh\n   cd '<run directory>' && python3 '<skill directory>/scripts/run_ideas_stages.py' core --run-dir .\n   ```\n\n   Every core call is non-final, so its one permitted revision runs in the same run.\n5. Read the script's structured stdout (`stage`, `status`, `errors`, `revision_remaining`) as well\n   as its exit code. Both `ok` and recoverable `needs_revision` exit `0`; the latter keeps the run\n   open but does not validate or render a deliverable.\n   - `status=\"ok\"` with report paths (exit `0`): run step 7, then deliver. The `--concise` output is the sole Creator-facing artifact: `RESULT.md`. The `--full` output is an audit-only artifact; keep `IDEA_REPORT_FULL.md` in the run directory and never deliver it or copy it to `RESULT.md`.\n   - `status=\"needs_revision\"` with `revision_remaining=1` (exit `0`, unvalidated): use the returned errors and `revision_brief.json` to revise `idea_set.json` **once**, then run the same core command in the same run directory. Do not rerun prep, reset the attempt counter, or replace this runnable revision with an unvalidated prose answer. If the working file cannot be read directly, write the corrected file into the same run directory from the retained IdeaSet content and returned errors.\n   - `status=\"not_met\"` (exit `3`): record not_met from `stage_timing.json`; do not start another\n     creative pass or loosen validation.\n   - `status=\"failed\"`, absent/unreadable script status, or an unavailable execution tool: diagnose\n     the specific failure. Do not infer successful validation or permission for another creative\n     pass. If recovery cannot complete, say the draft is unvalidated rather than presenting it as\n     the completed skill result.\n6. If machine-readable JSON is requested, emit only the declared JSON object. Creator-facing\n   Markdown is a renderer projection and must not be appended to strict JSON.\n7. Only after core reports `status=\"ok\"`, run the final step from the run directory, without\n   running core again or consuming another generation attempt:\n\n   ```sh\n   cd '<run directory>' && python3 '<skill directory>/scripts/validate_ideas.py' idea-set idea_set.json request.json && test -s RESULT.md\n   ```\n\n   This is the final step; its deliverable is `RESULT.md` at the run root, not under `report/`.\n   There is no final step for `needs_revision`, `not_met` or a failed/unreadable stage result. A\n   zero exit with `needs_revision` never permits emitting the draft as a validated report.\n\n`build_idea_request.py`, `validate_ideas.py` and `render_idea_report.py` exist for the stage\nrunner; the stage runner is the required execution path so fixed steps are not each re-decided.\n\n## What may not be claimed\n\nRead `references/idea-set-rules.md` whole before writing `idea_set.json`; it holds the per-intent\ncontract and ranking rules. In short:\n\n- Never invent loss amounts, customer outcomes, efficiency gains, market facts, policy facts,\n  numbers, URLs or metrics to satisfy a schema. Exact numbers trace to evidence.\n- `source_backed` only when upstream/context refs and evidence refs are present; otherwise\n  `brief_based` or `hypothesis`. `why_now` is an evidence-backed claim only when a dated source\n  supports it; otherwise say timeliness is unverified.\n- A request for account performance, trends, competitors, Creator context, or a specific video\n  cannot silently become a brief-only request; without the evidence and without explicit fallback,\n  return the missing-source block without ideas.\n- `selection_status` remains `candidate` until the user selects an idea.\n\n## Report language and conversation context\n\nSet `report_language` on both IdeaRequest and IdeaSet to the language requested for the final\nreport and interaction (BCP 47 tag), separate from `language_targets`. Infer it from the current\nuser request unless explicitly specified earlier; preserve quotations, titles and supplied creative\ntext verbatim, and generate all explanatory fields, questions and rationale in that language. Every\nexplicit `report_language` also needs `evidence_gap_translations` entries. Read\n`references/report-language.md` whole before writing `idea_set.json`.\n\nBefore asking for a topic, audience, goal or evidence, reuse the relevant conversation up to the\ncurrent turn. Do not import subsequent replies. When no explicit topic or usable evidence exists,\nkeep the existing generation gate and ask only for the topic/niche (or an account/evidence\nsource); a platform name and a requested idea count do not supply a niche. Normal clarification is\nnot a completed idea-generation task.\n\n## Delivery\n\nBefore delivery, read the complete `RESULT.md` from the run directory, continuing through every\nchunk when the host's file reading pages. `status=\"ok\"`, the final check and the original rendered\n`RESULT.md` are the delivery gate. Copy `RESULT.md` exactly to the Creator-facing surface, as\nnatural prose: the structured objects remain the source of truth. Deliver it once, keep the audit\nfiles in the run directory, and do not append a second paraphrased report. An invalid or partial\nresult keeps its actual status, evidence gaps and source limitations. When a missing upstream\nartifact blocked the request, name the Skill that produces it as the next step.\n"
}