@synap-core/workspace-templates 0.12.0 → 0.24.0

package/src/replicate-rvm.test.ts

@@ -0,0 +1,504 @@
+/**
+ * Replicate Robust Video Matting (capability `replicate-rvm`): the marketplace
+ * tool that serves `edit_video` (founder decisions be0deab7 and ac1ba2b6,
+ * 2026-10-28). The app's input is `{ video: <https URL> }`.
+ *
+ * SEAM: each verb's REAL `code` body, run the way the pod's executor wraps it
+ * (`async (args, context) => { <code> }` with `callProvider` in scope),
+ * against Replicate responses shaped like its documented prediction object
+ * (`{ id, version, input, status, output, error }`). The request asserted is
+ * exactly what `callProvider` would send to api.replicate.com/v1.
+ *
+ * The long-run design under test: an isolate has no timer, so the matte verb
+ * starts every prediction, waits on the LAST one only (`Prefer: wait=60`),
+ * reads the others once, and hands anything unfinished to the read verb
+ * through `next` instead of starting the predictions again.
+ *
+ * NOT covered: Replicate's live behaviour (payloads are hand-written from its
+ * API page), the pod's propose-moment arg check and the IS isolate (Node's
+ * AsyncFunction is used).
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const manifest = JSON.parse(
+  readFileSync(
+    join(HERE, "../capabilities/replicate-rvm.capability.json"),
+    "utf8"
+  )
+);
+type Skill = {
+  name: string;
+  intent?: string;
+  code?: string;
+  parameters?: Record<string, string>;
+  metadata?: Record<string, unknown>;
+};
+const skills = manifest.spec.skills as Skill[];
+const verb = (name: string) => skills.find((s) => s.name === name)!;
+
+const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor as new (
+  ...args: string[]
+) => (...a: unknown[]) => Promise<unknown>;
+const matte = new AsyncFunction(
+  "args",
+  "context",
+  "callProvider",
+  verb("replicate_rvm_matte").code!
+);
+const result = new AsyncFunction(
+  "args",
+  "context",
+  "callProvider",
+  verb("replicate_rvm_result").code!
+);
+
+const VERSION =
+  "73d2128a371922d5d1abf0712a1d974be0e4e2358cc1218e4e34714767232bac";
+const VIDEO =
+  "https://pod.example.synap.live/files/take-1.mp4?sig=abc&exp=1730000000";
+const OUT = (t: string) => `https://replicate.delivery/xezq/${t}/output.mp4`;
+
+type Call = {
+  tool: string;
+  method: string;
+  path: string;
+  body?: Record<string, any>;
+  opts?: Record<string, any>;
+};
+type Pred = {
+  id: string;
+  status: string;
+  output?: unknown;
+  error?: string | null;
+  type: string;
+};
+
+/** A fake Replicate: POST creates a prediction in the state `onCreate` says; GET returns `onGet`. */
+function replicate(opts: {
+  onCreate: (type: string, waited: boolean) => Omit<Pred, "id" | "type">;
+  onGet?: (p: Pred) => Omit<Pred, "id" | "type">;
+}) {
+  const calls: Call[] = [];
+  const preds = new Map<string, Pred>();
+  let n = 0;
+  const callProvider = async (
+    tool: string,
+    method: string,
+    path: string,
+    body?: Record<string, any>,
+    o?: Record<string, any>
+  ) => {
+    calls.push({ tool, method, path, body, opts: o });
+    if (method === "POST") {
+      const type = body!.input.output_type;
+      const p: Pred = {
+        id: `pred${++n}abcdefgh`,
+        type,
+        ...opts.onCreate(type, o?.headers?.Prefer === "wait=60"),
+      };
+      preds.set(p.id, p);
+      return {
+        status: 201,
+        headers: {},
+        body: {
+          id: p.id,
+          version: body!.version,
+          input: body!.input,
+          status: p.status,
+          output: p.output ?? null,
+          error: p.error ?? null,
+        },
+      };
+    }
+    const id = path.split("/").pop()!;
+    const p = preds.get(id) ?? {
+      id,
+      type: "alpha-mask",
+      status: "succeeded",
+      output: OUT(id),
+    };
+    const next = opts.onGet ? { ...p, ...opts.onGet(p) } : p;
+    preds.set(id, next);
+    return {
+      status: 200,
+      headers: {},
+      body: {
+        id,
+        version: VERSION,
+        input: { input_video: VIDEO, output_type: next.type },
+        status: next.status,
+        output: next.output ?? null,
+        error: next.error ?? null,
+      },
+    };
+  };
+  return { calls, preds, callProvider };
+}
+
+describe("replicate-rvm — the capability serves edit_video", () => {
+  it("declares edit_video on the matte verb, a read-only result verb, and provides exactly what the verbs declare", () => {
+    expect(verb("replicate_rvm_matte")).toMatchObject({
+      intent: "edit_video",
+      parameters: {
+        video: "string?",
+        videoFile: "file:url?",
+        outputs: "array?",
+      },
+    });
+    expect(verb("replicate_rvm_result")).toMatchObject({
+      intent: "fetch_record",
+      metadata: { readOnly: true },
+      parameters: { predictionIds: "array" },
+    });
+    expect([...manifest.spec.provides].sort()).toEqual([
+      "edit_video",
+      "fetch_record",
+    ]);
+  });
+
+  it("maps the edit_video input { video } onto the matte verb, so a pod app's edit_video action reaches it (0368 inputMap)", () => {
+    expect(
+      (verb("replicate_rvm_matte") as Skill & { inputMap?: unknown }).inputMap
+    ).toEqual({ params: { video: "$.video" } });
+    expect(
+      (verb("replicate_rvm_result") as Skill & { inputMap?: unknown }).inputMap
+    ).toBeUndefined();
+  });
+
+  it("keeps the token in the vault, sent as a Bearer header to api.replicate.com/v1 only", () => {
+    const tool = manifest.spec.tools[0];
+    expect(tool).toMatchObject({
+      name: "replicate_api",
+      kind: "api",
+      credentialRef: "replicateApiTokenSecret",
+    });
+    expect(tool.config).toEqual({
+      baseUrl: "https://api.replicate.com/v1",
+      auth: { in: "header", name: "Authorization", prefix: "Bearer " },
+    });
+    expect(manifest.spec.vault[0]).toMatchObject({
+      ref: "replicateApiTokenSecret",
+      value: "{{replicateApiToken}}",
+    });
+    expect(manifest.spec.params).toEqual([
+      expect.objectContaining({ name: "replicateApiToken", required: true }),
+    ]);
+  });
+});
+
+describe("replicate_rvm_matte — one call on a warm model", () => {
+  it("starts alpha then foreground on the pinned version, waits only on the last, and returns both URLs", async () => {
+    const r = replicate({
+      onCreate: (type, waited) =>
+        waited
+          ? { status: "succeeded", output: OUT(type) }
+          : { status: "starting" },
+      onGet: (p) => ({ status: "succeeded", output: OUT(p.type) }),
+    });
+    const raw = (await matte({ video: VIDEO }, {}, r.callProvider)) as Record<
+      string,
+      any
+    >;
+    const posts = r.calls.filter((c) => c.method === "POST");
+    expect(posts.map((c) => c.body)).toEqual([
+      {
+        version: VERSION,
+        input: { input_video: VIDEO, output_type: "alpha-mask" },
+      },
+      {
+        version: VERSION,
+        input: { input_video: VIDEO, output_type: "foreground-mask" },
+      },
+    ]);
+    expect(posts.map((c) => c.opts?.headers?.Prefer ?? null)).toEqual([
+      null,
+      "wait=60",
+    ]);
+    expect(
+      posts.every(
+        (c) => c.tool === "replicate_api" && c.path === "/predictions"
+      )
+    ).toBe(true);
+    // The first one ran while the second waited: read once.
+    expect(
+      r.calls.filter((c) => c.method === "GET").map((c) => c.path)
+    ).toEqual(["/predictions/pred1abcdefgh"]);
+    expect(raw).toMatchObject({
+      success: true,
+      status: "succeeded",
+      alphaUrl: OUT("alpha-mask"),
+      foregroundUrl: OUT("foreground-mask"),
+      next: null,
+    });
+    expect(raw.predictionIds).toEqual(["pred1abcdefgh", "pred2abcdefgh"]);
+  });
+
+  it("a single output waits on that one and reads nothing", async () => {
+    const r = replicate({
+      onCreate: () => ({ status: "succeeded", output: OUT("a") }),
+    });
+    const raw = (await matte(
+      { video: VIDEO, outputs: ["alpha", "alpha"] },
+      {},
+      r.callProvider
+    )) as Record<string, any>;
+    expect(
+      r.calls.map((c) => `${c.method} ${c.opts?.headers?.Prefer ?? ""}`)
+    ).toEqual(["POST wait=60"]);
+    expect(raw.alphaUrl).toBe(OUT("a"));
+    expect(raw.foregroundUrl).toBeUndefined();
+  });
+});
+
+describe("replicate_rvm_matte — a long take is handed to the read verb, never restarted", () => {
+  it("returns processing with next = replicate_rvm_result and the same ids", async () => {
+    const r = replicate({
+      onCreate: () => ({ status: "processing" }),
+      onGet: () => ({ status: "processing" }),
+    });
+    const raw = (await matte({ video: VIDEO }, {}, r.callProvider)) as Record<
+      string,
+      any
+    >;
+    expect(raw.status).toBe("processing");
+    expect(raw.alphaUrl).toBeUndefined();
+    expect(raw.next).toEqual({
+      verbId: "replicate_rvm_result",
+      parameters: { predictionIds: ["pred1abcdefgh", "pred2abcdefgh"] },
+    });
+    expect(r.calls.filter((c) => c.method === "POST")).toHaveLength(2);
+  });
+
+  it("the read verb finishes it: GET only, both URLs by output type", async () => {
+    let finished = false;
+    const r = replicate({
+      onCreate: () => ({ status: "processing" }),
+      onGet: (p) =>
+        finished
+          ? { status: "succeeded", output: OUT(p.type) }
+          : { status: "processing" },
+    });
+    const first = (await matte({ video: VIDEO }, {}, r.callProvider)) as Record<
+      string,
+      any
+    >;
+    finished = true;
+    const calls = r.calls.length;
+    const done = (await result(
+      first.next.parameters,
+      {},
+      async (...a: any[]) => {
+        // Only reads after this point.
+        expect(a[1]).toBe("GET");
+        return (r.callProvider as any)(...a);
+      }
+    )) as Record<string, any>;
+    expect(r.calls.length - calls).toBe(2);
+    expect(done).toMatchObject({
+      success: true,
+      status: "succeeded",
+      alphaUrl: OUT("alpha-mask"),
+      foregroundUrl: OUT("foreground-mask"),
+      next: null,
+    });
+  });
+
+  it("the read verb refuses an id that is not an RVM prediction", async () => {
+    const callProvider = async () => ({
+      status: 200,
+      body: {
+        id: "otherpred123",
+        version: "0".repeat(64),
+        input: {},
+        status: "succeeded",
+        output: OUT("x"),
+      },
+    });
+    await expect(
+      result({ predictionIds: ["otherpred123"] }, {}, callProvider)
+    ).rejects.toThrow(/not a Robust Video Matting prediction/);
+  });
+});
+
+describe("replicate_rvm_matte — failures are loud", () => {
+  it("a failed prediction fails the run with Replicate's error", async () => {
+    const r = replicate({
+      onCreate: (_t, waited) =>
+        waited
+          ? { status: "failed", error: "CUDA out of memory" }
+          : { status: "starting" },
+      onGet: () => ({ status: "processing" }),
+    });
+    await expect(matte({ video: VIDEO }, {}, r.callProvider)).rejects.toThrow(
+      /foreground prediction pred2abcdefgh failed: CUDA out of memory/
+    );
+  });
+
+  it("a refused create names the status and Replicate's detail", async () => {
+    const callProvider = async () => ({
+      status: 402,
+      body: { detail: "You have insufficient credit" },
+    });
+    await expect(matte({ video: VIDEO }, {}, callProvider)).rejects.toThrow(
+      /status 402\): You have insufficient credit/
+    );
+  });
+
+  it("a proposal envelope is returned as the record, nothing else runs", async () => {
+    const calls: string[] = [];
+    const callProvider = async (_t: string, m: string) => (
+      calls.push(m),
+      { proposed: true, proposalId: "p1" }
+    );
+    expect(await matte({ video: VIDEO }, {}, callProvider)).toEqual({
+      success: false,
+      proposed: true,
+      proposalId: "p1",
+      started: [],
+    });
+    expect(calls).toEqual(["POST"]);
+  });
+});
+
+describe("replicate_rvm_matte — strict inputs, nothing undeclared reaches Replicate", () => {
+  const ok = () =>
+    replicate({ onCreate: () => ({ status: "succeeded", output: OUT("a") }) });
+
+  it.each([
+    ["no video", {}],
+    ["http, not https", { video: "http://example.com/a.mp4" }],
+    [
+      "credentials in the URL",
+      { video: "https://user:pass@example.com/a.mp4" },
+    ],
+    ["a data URL", { video: "data:video/mp4;base64,AAAA" }],
+    ["a vault ref", { video: "vault://abc" }],
+    [
+      "a URL over the intent's 2048 characters",
+      { video: "https://example.com/" + "a".repeat(2029) },
+    ],
+    ["an unknown output", { video: VIDEO, outputs: ["depth"] }],
+    ["an empty outputs list", { video: VIDEO, outputs: [] }],
+    ["Replicate's own spelling", { input_video: VIDEO }],
+  ])("refuses %s before any call", async (_why, args) => {
+    const r = ok();
+    await expect(matte(args, {}, r.callProvider)).rejects.toThrow(
+      /replicate_rvm_matte:/
+    );
+    expect(r.calls).toEqual([]);
+  });
+
+  it("undeclared keys are never forwarded", async () => {
+    const r = ok();
+    await matte(
+      {
+        video: VIDEO,
+        version: "evil",
+        input: { x: 1 },
+        webhook: "https://evil.example",
+        apiKey: "sk",
+      },
+      {},
+      r.callProvider
+    );
+    for (const c of r.calls.filter((x) => x.method === "POST")) {
+      expect(Object.keys(c.body!).sort()).toEqual(["input", "version"]);
+      expect(c.body!.version).toBe(VERSION);
+      expect(Object.keys(c.body!.input).sort()).toEqual([
+        "input_video",
+        "output_type",
+      ]);
+    }
+  });
+
+  it("the read verb refuses a malformed id before any call", async () => {
+    const calls: unknown[] = [];
+    await expect(
+      result({ predictionIds: ["../account"] }, {}, async (...a: unknown[]) =>
+        calls.push(a)
+      )
+    ).rejects.toThrow(/not a Replicate prediction id/);
+    expect(calls).toEqual([]);
+  });
+});
+
+/**
+ * Phase 1c (pod files to tools by URL, backend #469): the take is a POD FILE.
+ * The caller passes its file entity id as `videoFile` (declared `file:url`);
+ * the pod mints a fresh signed URL at run time and swaps it in, so the skill
+ * receives an https URL. The verb is async so that URL lives 6 h (a cold
+ * Replicate start may fetch it late). The edit_video intent input stays an
+ * https `video`, mapped by inputMap.
+ */
+describe("replicate_rvm_matte — a pod file in, signed by the pod", () => {
+  const SIGNED =
+    "https://s3.example.synap.live/pod/files/take-1.mp4?X-Amz-Signature=secret123&X-Amz-Expires=21600";
+
+  it("declares videoFile as a pod file by URL, async (6 h link), never read-only", () => {
+    const m = verb("replicate_rvm_matte") as Skill & { executionMode?: string };
+    expect(m.parameters?.videoFile).toBe("file:url?");
+    expect(m.executionMode).toBe("async");
+    expect(m.metadata?.readOnly).toBeUndefined();
+    expect((m as Skill & { inputMap?: unknown }).inputMap).toEqual({
+      params: { video: "$.video" },
+    });
+  });
+
+  it("sends the signed URL the pod swapped in as Replicate's input_video, and says the source", async () => {
+    const r = replicate({
+      onCreate: () => ({ status: "succeeded", output: OUT("a") }),
+    });
+    const raw = (await matte(
+      { videoFile: SIGNED },
+      {},
+      r.callProvider
+    )) as Record<string, any>;
+    const posts = r.calls.filter((c) => c.method === "POST");
+    expect(posts.map((c) => c.body!.input.input_video)).toEqual([
+      SIGNED,
+      SIGNED,
+    ]);
+    expect(raw.source).toBe("pod-file");
+    expect(JSON.stringify(raw)).not.toContain("X-Amz-Signature");
+  });
+
+  it("a URL caller is still served, marked as such", async () => {
+    const r = replicate({
+      onCreate: () => ({ status: "succeeded", output: OUT("a") }),
+    });
+    const raw = (await matte({ video: VIDEO }, {}, r.callProvider)) as Record<
+      string,
+      any
+    >;
+    expect(raw.source).toBe("url");
+  });
+
+  it("refuses both, neither, and an unswapped file id, without echoing a signed URL", async () => {
+    const r = replicate({
+      onCreate: () => ({ status: "succeeded", output: OUT("a") }),
+    });
+    await expect(
+      matte({ video: VIDEO, videoFile: SIGNED }, {}, r.callProvider)
+    ).rejects.toThrow(/not both/);
+    await expect(matte({}, {}, r.callProvider)).rejects.toThrow(
+      /video \(an https URL\) or videoFile \(a pod file\) is required/
+    );
+    const err = await matte(
+      { videoFile: "8d2f4c1e-0b7a-4c55-9a7e-3f1f0d1c2b3a" },
+      {},
+      r.callProvider
+    ).catch((e: Error) => e.message);
+    expect(err).toMatch(/did not arrive as a signed pod file URL/);
+    const http = await matte(
+      { videoFile: "http://s3.example/x.mp4?X-Amz-Signature=secret123" },
+      {},
+      r.callProvider
+    ).catch((e: Error) => e.message);
+    expect(http).not.toContain("secret123");
+    expect(r.calls).toEqual([]);
+  });
+});

package/src/research-base.yaml

@@ -26,6 +26,12 @@ meta:
   color: "#8B5CF6"
   tags: [research, knowledge, graph, sources, evidence, learning]
   isPublic: true
+  # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
+  intent:
+    label: Research
+    produces:
+      - profile: hypothesis
+      - profile: finding
 
 workspace:
   name: Research
@@ -178,6 +184,15 @@ profiles:
     icon: git-branch
     color: violet
     description: A candidate theory or answer under test — argued for and against by sources.
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: stance
+      options:
+        - { key: proposed, category: open }
+        - { key: supported, category: done }
+        - { key: contested, category: active }
+        - { key: refuted, category: lost }
+        - { key: superseded, category: lost }
     properties:
       - slug: statement
         label: Statement
@@ -204,6 +219,13 @@ profiles:
     icon: check-circle
     color: "#10B981"
     description: A validated fact — the thing established between the question, the sources, and the reasoning. Carries calibrated confidence and links to its evidence.
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: status
+      options:
+        - { key: validated, category: done }
+        - { key: provisional, category: open }
+        - { key: retracted, category: lost }
     properties:
       - slug: claim
         label: Claim
@@ -369,33 +391,39 @@ entityLinks:
       label: About,
     }
 
-# The one universal playbook — bound to `question`, so any question can launch it
-# from its detail page (see actionPlacements) or auto-match as a session. It runs
-# the full method: gather + rank sources (keep the rejects), form and weigh
-# hypotheses, emit findings with honest confidence, and place them on the map.
+# "Research a Question" runs a question's lifecycle (open → exploring →
+# answered): a new question proposes it, and any question can launch it from its
+# detail page (see actionPlacements). It runs the full method: gather + rank
+# sources (keep the rejects), form and weigh hypotheses, emit findings with
+# honest confidence, and place them on the map. "Turn a finding into content"
+# reads a finding's status: a validated finding proposes post ideas from it.
 playbooks:
   - name: Research a Question
     description: Investigate a question end-to-end — gather and rank sources (keeping the rejected ones), weigh hypotheses, emit findings with calibrated confidence, and map them onto the knowledge graph.
     goalTemplate: >-
-      Investigate the question {question} and record the WHOLE investigation, not
-      just the answer. Steps: (1) Use the source-triage skill to gather sources
-      widely via web search, classify each by type and credibility, and create a
+      Investigate the question {question} and record the WHOLE investigation,
+      not just the answer; each stage moves the question's status. FRAME:
+      restate the question so it can be answered, and say what evidence would
+      answer it. GATHER: use the source-triage skill to gather sources widely
+      via web search, classify each by type and credibility, and create a
       `source` entity for every one — including the ones you rejected, marked
-      rejected with a reason (never silently drop a source). (2) Form the
-      candidate answers as `hypothesis` entities and link each to the question;
-      link every source that bears on a hypothesis with `supports` or
-      `contradicts`. (3) Use the evidence-synthesis skill to weigh the supporting
-      vs contradicting sources and emit `finding` entities with honestly
-      calibrated confidence, each `supported_by` its sources and `derived_from`
-      this research. (4) Use the concept-cartography skill to place the findings
-      onto the knowledge map — resolve or create the `field`/`concept` entities
-      and wire `about` / `part_of` / `overlaps_with` / `prerequisite_of` edges,
-      deduping against what already exists. (5) Create the `research` entity that
-      `investigates` the question and `explored` the sources, write its
-      conclusion and confidence, and set the question's status to answered. Every
-      write is proposal-gated and reviewable.
+      rejected with a reason (never silently drop a source). WEIGH: form the
+      candidate answers as `hypothesis` entities that answer the question; link
+      every source that bears on a hypothesis with `supports` or
+      `contradicts`; use the evidence-synthesis skill to emit `finding`
+      entities with honestly calibrated confidence, each `supported_by` its
+      sources and `derived_from` this research; use the concept-cartography
+      skill to place the findings onto the knowledge map. ANSWER: create the
+      `research` entity that `investigates` the question and `explored` the
+      sources, write its conclusion and confidence, and set the question to
+      answered. Abandoning a question is a person's call. Every write is
+      proposal-gated and reviewable.
     subjectProfile:
       profileSlug: question
+      statusProperty: questionStatus
+    humanOnlyStatuses: [abandoned]
+    activators:
+      - { on: created, mode: propose }
     params:
       - { name: question, type: entity, label: Question, required: true }
     executor: is-agent
@@ -406,6 +434,68 @@ playbooks:
       - exa_search
       - entity.create
     status: active
+    requiredIntents: [search_external]
+    expectedOutputs:
+      - { kind: research, label: Research record, relationToSubject: investigates }
+      - { kind: hypothesis, label: Candidate answers, relationToSubject: answers }
+    stages:
+      - key: frame
+        name: Frame
+        category: planned
+        subjectStatus: open
+        goal: Restate the question so it can be answered and say what evidence would answer it.
+        criteria:
+          - key: question-answerable
+            statement: The question says what evidence would answer it.
+            check: { kind: judge }
+      - key: gather
+        name: Gather
+        category: started
+        subjectStatus: exploring
+        goal: Gather and classify sources, keeping every rejected source with its reason.
+        criteria:
+          - key: sources-kept
+            statement: Every source considered exists as a source entity, rejected ones with a reason.
+            check: { kind: judge }
+      - key: weigh
+        name: Weigh
+        category: started
+        goal: Form hypotheses, link evidence for and against, and emit findings with calibrated confidence.
+        criteria:
+          - key: findings-cited
+            statement: Every finding is supported by at least one source.
+            check: { kind: judge }
+          - key: counter-evidence
+            statement: Every hypothesis lists the sources that contradict it, or says none were found.
+            check: { kind: judge }
+      - key: answer
+        name: Answer
+        category: completed
+        subjectStatus: answered
+        goal: Record the research, its conclusion and confidence, and mark the question answered.
+        gate: { kind: check }
+        onFail: { toStage: weigh }
+
+  - name: Turn a finding into content
+    description: When a finding is validated, propose the posts that would share it, each linked to the finding.
+    goalTemplate: >-
+      Turn this validated finding ({finding}) into content. Read the finding,
+      its sources and the research it came from. Propose one to three posts
+      that share it with the audience — each created at the Idea status, on
+      the pillar it fits, with its hook and the reason it is worth making —
+      and link each one derived_from the finding. Quote only what the sources
+      support.
+    subjectProfile:
+      profileSlug: finding
+      statusProperty: status
+    activators:
+      - { on: enters_status, status: validated, mode: propose }
+    params:
+      - { name: finding, type: entity, label: Finding, required: true }
+    executor: is-agent
+    status: active
+    expectedOutputs:
+      - { kind: post, label: Post idea, relationToSubject: derived_from }
 
 # A "Research this" action on every question's detail page — the entity is the
 # starter of the flow, exactly as designed.
@@ -423,6 +513,15 @@ integrations:
   - templateKey: research-methods
   - templateKey: exa
 
+# ── taskIntents — WHAT THIS WORKSPACE NEEDS TO FUNCTION ───────────────────
+# Closed vocabulary: `@synap-core/types/capability-intents` (pod migrations
+# 0283/0284). DERIVED from the declared intents of this template's own
+# `integrations` capability packs — not hand-guessed. Checked at authoring
+# time by `validateTemplate` (`task-intent-unknown`) and by
+# `src/task-intents.test.ts`.
+taskIntents:
+  - search_external
+
 onboarding:
   goal: >
     Seed the workspace with the first real questions worth researching and the