titan-agent 6.5.2 → 7.0.0

package/dist/skills/builtin/delegate_agent.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import { execSync } from "child_process";
+import { registerSkill } from "../registry.js";
+import logger from "../../utils/logger.js";
+const COMPONENT = "DelegateAgent";
+const EXTERNAL_AGENTS = {
+  codex: { bin: "codex", label: "OpenAI Codex CLI", buildArgs: (t) => ["exec", "--full-auto", t] },
+  aider: { bin: "aider", label: "aider", buildArgs: (t) => ["--message", t, "--yes-always"] },
+  goose: { bin: "goose", label: "Goose", buildArgs: (t) => ["run", "-t", t] },
+  gemini: { bin: "gemini", label: "Gemini CLI", buildArgs: (t) => ["-p", t] },
+  opencode: { bin: "opencode", label: "OpenCode", buildArgs: (t) => ["run", t] }
+};
+const FORBIDDEN = /* @__PURE__ */ new Set(["claude", "claude-code", "claude_code"]);
+function detectAvailableAgents(isAvailable) {
+  return Object.entries(EXTERNAL_AGENTS).filter(([name, spec]) => !FORBIDDEN.has(name) && isAvailable(spec.bin)).map(([name]) => name);
+}
+function buildAgentCommand(agent, task) {
+  if (FORBIDDEN.has(agent)) throw new Error("Delegation to Claude Code is not permitted (standing rule).");
+  const spec = EXTERNAL_AGENTS[agent];
+  if (!spec) throw new Error(`Unknown agent "${agent}". Known: ${Object.keys(EXTERNAL_AGENTS).join(", ")}`);
+  if (!task || !task.trim()) throw new Error("A task is required.");
+  return { cmd: spec.bin, args: spec.buildArgs(task) };
+}
+function binExists(bin) {
+  try {
+    execSync(`command -v ${bin}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runAgent(cmd, args, cwd, timeoutMs) {
+  return new Promise((resolve) => {
+    let out = "";
+    const child = spawn(cmd, args, { cwd, env: process.env });
+    const cap = (d) => {
+      out += d.toString();
+      if (out.length > 2e4) out = out.slice(-2e4);
+    };
+    child.stdout.on("data", cap);
+    child.stderr.on("data", cap);
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve({ ok: false, output: out + `
+[delegation timed out after ${timeoutMs}ms]` });
+    }, timeoutMs);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      resolve({ ok: false, output: `Failed to launch ${cmd}: ${e.message}` });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ ok: code === 0, output: out || `(no output, exit ${code})` });
+    });
+  });
+}
+function registerDelegateAgentSkill() {
+  registerSkill(
+    { name: "delegate_agent", description: "Delegate a coding task to an external coding agent (Codex/aider/Goose/\u2026)", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "delegate_agent",
+      description: 'Delegate a coding task to an EXTERNAL coding agent installed on this machine (Codex CLI, aider, Goose, Gemini CLI, OpenCode). Detects what is available, runs it non-interactively against your task, and returns its output.\n\nUSE THIS WHEN: you want a specialist coding agent to handle a self-contained implementation task. Args: task (required), agent (optional \u2014 auto-picks the first available), cwd (optional), timeoutSeconds (optional, default 300). Returns the agent output or an honest "not installed" message. (Claude Code is intentionally not supported.)',
+      parameters: {
+        type: "object",
+        properties: {
+          task: { type: "string", description: "The coding task to delegate (a clear, self-contained instruction)." },
+          agent: { type: "string", enum: Object.keys(EXTERNAL_AGENTS), description: "Which agent (optional \u2014 defaults to the first available)." },
+          cwd: { type: "string", description: "Working directory (defaults to the current directory)." },
+          timeoutSeconds: { type: "number", description: "Max seconds before killing the agent (default 300)." }
+        },
+        required: ["task"]
+      },
+      execute: async (args) => {
+        const task = String(args.task || "");
+        if (!task.trim()) return 'delegate_agent requires a "task".';
+        const available = detectAvailableAgents(binExists);
+        if (available.length === 0) {
+          return `No external coding agent is installed. Tried: ${Object.values(EXTERNAL_AGENTS).map((a) => a.bin).join(", ")}. Install one (e.g. \`npm i -g @openai/codex\` or \`pipx install aider-chat\`) to use delegation. (Claude Code is intentionally not supported.)`;
+        }
+        const agent = args.agent || available[0];
+        if (!available.includes(agent)) {
+          return `Agent "${agent}" is not installed. Available: ${available.join(", ")}.`;
+        }
+        let cmd, cmdArgs;
+        try {
+          ({ cmd, args: cmdArgs } = buildAgentCommand(agent, task));
+        } catch (e) {
+          return e.message;
+        }
+        const cwd = args.cwd || process.cwd();
+        const timeoutMs = Math.max(5e3, Number(args.timeoutSeconds || 300) * 1e3);
+        logger.info(COMPONENT, `Delegating to ${agent} (${EXTERNAL_AGENTS[agent].label}) in ${cwd}`);
+        const { ok, output } = await runAgent(cmd, cmdArgs, cwd, timeoutMs);
+        return `[${EXTERNAL_AGENTS[agent].label} ${ok ? "completed" : "failed/timed-out"}]
+${output}`;
+      }
+    }
+  );
+}
+export {
+  EXTERNAL_AGENTS,
+  buildAgentCommand,
+  detectAvailableAgents,
+  registerDelegateAgentSkill
+};
+//# sourceMappingURL=delegate_agent.js.map

package/dist/skills/builtin/delegate_agent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/skills/builtin/delegate_agent.ts"],"sourcesContent":["/**\n * TITAN — External coding-agent delegation (v7.0)\n *\n * Orchestrate OTHER coding agents (Codex CLI, aider, Goose, Gemini CLI, …) as\n * sub-agents: detect what's installed, spawn one with a task, capture its output.\n * Honestly disables when none is installed.\n *\n * STANDING RULE: TITAN must NEVER invoke Claude Code / the `claude` CLI at\n * runtime. `claude` is deliberately absent from the registry and rejected.\n *\n * detectAvailableAgents() + buildAgentCommand() are pure (dependency-injected)\n * for tests; the skill wires them to real `which` + `spawn`.\n */\nimport { spawn } from 'child_process';\nimport { execSync } from 'child_process';\nimport { registerSkill } from '../registry.js';\nimport logger from '../../utils/logger.js';\n\nconst COMPONENT = 'DelegateAgent';\n\ninterface AgentSpec {\n    bin: string;\n    label: string;\n    /** Build the argv to run the agent non-interactively against a task. */\n    buildArgs: (task: string) => string[];\n}\n\n/** Supported external coding agents. Claude Code is intentionally excluded. */\nexport const EXTERNAL_AGENTS: Record<string, AgentSpec> = {\n    codex:    { bin: 'codex',    label: 'OpenAI Codex CLI', buildArgs: (t) => ['exec', '--full-auto', t] },\n    aider:    { bin: 'aider',    label: 'aider',            buildArgs: (t) => ['--message', t, '--yes-always'] },\n    goose:    { bin: 'goose',    label: 'Goose',            buildArgs: (t) => ['run', '-t', t] },\n    gemini:   { bin: 'gemini',   label: 'Gemini CLI',       buildArgs: (t) => ['-p', t] },\n    opencode: { bin: 'opencode', label: 'OpenCode',         buildArgs: (t) => ['run', t] },\n};\n\n/** Names that must NEVER be delegated to (standing rule). */\nconst FORBIDDEN = new Set(['claude', 'claude-code', 'claude_code']);\n\n/**\n * Which agents are available, given an `isAvailable(bin) => boolean` probe.\n * Pure — inject the probe for tests.\n */\nexport function detectAvailableAgents(isAvailable: (bin: string) => boolean): string[] {\n    return Object.entries(EXTERNAL_AGENTS)\n        .filter(([name, spec]) => !FORBIDDEN.has(name) && isAvailable(spec.bin))\n        .map(([name]) => name);\n}\n\n/** Build the spawn command for an agent + task. Throws on unknown/forbidden. */\nexport function buildAgentCommand(agent: string, task: string): { cmd: string; args: string[] } {\n    if (FORBIDDEN.has(agent)) throw new Error('Delegation to Claude Code is not permitted (standing rule).');\n    const spec = EXTERNAL_AGENTS[agent];\n    if (!spec) throw new Error(`Unknown agent \"${agent}\". Known: ${Object.keys(EXTERNAL_AGENTS).join(', ')}`);\n    if (!task || !task.trim()) throw new Error('A task is required.');\n    return { cmd: spec.bin, args: spec.buildArgs(task) };\n}\n\n/** Real PATH probe via `command -v`. */\nfunction binExists(bin: string): boolean {\n    try { execSync(`command -v ${bin}`, { stdio: 'ignore' }); return true; } catch { return false; }\n}\n\n/** Run an external agent, capturing combined output (bounded). */\nfunction runAgent(cmd: string, args: string[], cwd: string, timeoutMs: number): Promise<{ ok: boolean; output: string }> {\n    return new Promise((resolve) => {\n        let out = '';\n        const child = spawn(cmd, args, { cwd, env: process.env });\n        const cap = (d: Buffer) => { out += d.toString(); if (out.length > 20000) out = out.slice(-20000); };\n        child.stdout.on('data', cap);\n        child.stderr.on('data', cap);\n        const timer = setTimeout(() => { child.kill('SIGKILL'); resolve({ ok: false, output: out + `\\n[delegation timed out after ${timeoutMs}ms]` }); }, timeoutMs);\n        child.on('error', (e) => { clearTimeout(timer); resolve({ ok: false, output: `Failed to launch ${cmd}: ${e.message}` }); });\n        child.on('close', (code) => { clearTimeout(timer); resolve({ ok: code === 0, output: out || `(no output, exit ${code})` }); });\n    });\n}\n\nexport function registerDelegateAgentSkill(): void {\n    registerSkill(\n        { name: 'delegate_agent', description: 'Delegate a coding task to an external coding agent (Codex/aider/Goose/…)', version: '1.0.0', source: 'bundled', enabled: true },\n        {\n            name: 'delegate_agent',\n            description:\n                'Delegate a coding task to an EXTERNAL coding agent installed on this machine (Codex CLI, aider, Goose, Gemini CLI, OpenCode). Detects what is available, runs it non-interactively against your task, and returns its output.\\n\\n' +\n                'USE THIS WHEN: you want a specialist coding agent to handle a self-contained implementation task. Args: task (required), agent (optional — auto-picks the first available), cwd (optional), timeoutSeconds (optional, default 300). Returns the agent output or an honest \"not installed\" message. (Claude Code is intentionally not supported.)',\n            parameters: {\n                type: 'object',\n                properties: {\n                    task: { type: 'string', description: 'The coding task to delegate (a clear, self-contained instruction).' },\n                    agent: { type: 'string', enum: Object.keys(EXTERNAL_AGENTS), description: 'Which agent (optional — defaults to the first available).' },\n                    cwd: { type: 'string', description: 'Working directory (defaults to the current directory).' },\n                    timeoutSeconds: { type: 'number', description: 'Max seconds before killing the agent (default 300).' },\n                },\n                required: ['task'],\n            },\n            execute: async (args: Record<string, unknown>): Promise<string> => {\n                const task = String(args.task || '');\n                if (!task.trim()) return 'delegate_agent requires a \"task\".';\n                const available = detectAvailableAgents(binExists);\n                if (available.length === 0) {\n                    return `No external coding agent is installed. Tried: ${Object.values(EXTERNAL_AGENTS).map((a) => a.bin).join(', ')}. Install one (e.g. \\`npm i -g @openai/codex\\` or \\`pipx install aider-chat\\`) to use delegation. (Claude Code is intentionally not supported.)`;\n                }\n                const agent = (args.agent as string) || available[0];\n                if (!available.includes(agent)) {\n                    return `Agent \"${agent}\" is not installed. Available: ${available.join(', ')}.`;\n                }\n                let cmd: string, cmdArgs: string[];\n                try { ({ cmd, args: cmdArgs } = buildAgentCommand(agent, task)); }\n                catch (e) { return (e as Error).message; }\n                const cwd = (args.cwd as string) || process.cwd();\n                const timeoutMs = Math.max(5_000, Number(args.timeoutSeconds || 300) * 1000);\n                logger.info(COMPONENT, `Delegating to ${agent} (${EXTERNAL_AGENTS[agent].label}) in ${cwd}`);\n                const { ok, output } = await runAgent(cmd, cmdArgs, cwd, timeoutMs);\n                return `[${EXTERNAL_AGENTS[agent].label} ${ok ? 'completed' : 'failed/timed-out'}]\\n${output}`;\n            },\n        },\n    );\n}\n"],"mappings":"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","names":[]}

package/dist/skills/builtin/memory_map.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { registerSkill } from "../registry.js";
+import { summarizeMemoryTaxonomy, renderMemoryTaxonomy } from "../../memory/taxonomy.js";
+import { loadConfig } from "../../config/config.js";
+import logger from "../../utils/logger.js";
+const COMPONENT = "MemoryMap";
+function registerMemoryMapSkill() {
+  registerSkill(
+    { name: "memory_map", description: "Describe TITAN's named memory taxonomy and which types are active", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "memory_map",
+      description: `Describe TITAN's MEMORY TAXONOMY \u2014 the nine named memory types (working, episodic, semantic, procedural, emotional/drive, prospective, relational, narrative, shared), what each captures, the real subsystem backing it, and whether it's active right now.
+
+USE THIS WHEN: "what do you remember?", "what kinds of memory do you have?", "what's your memory architecture?", or to explain how TITAN persists context across turns and sessions.`,
+      parameters: { type: "object", properties: {}, required: [] },
+      execute: async () => {
+        try {
+          const config = loadConfig();
+          let hindsightConnected = false;
+          try {
+            const { memory } = await import("../../memory/facade.js");
+            hindsightConnected = Boolean(await memory.episodic.isCrossSessionConnected());
+          } catch {
+          }
+          const summary = summarizeMemoryTaxonomy(config, { hindsightConnected });
+          logger.info(COMPONENT, `Memory taxonomy: ${summary.active}/${summary.total} types active`);
+          return renderMemoryTaxonomy(summary);
+        } catch (e) {
+          return `Failed to summarize memory taxonomy: ${e.message}`;
+        }
+      }
+    }
+  );
+}
+export {
+  registerMemoryMapSkill
+};
+//# sourceMappingURL=memory_map.js.map

package/dist/skills/builtin/memory_map.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/skills/builtin/memory_map.ts"],"sourcesContent":["/**\n * TITAN — Memory taxonomy skill (v7.0)\n *\n * Surfaces TITAN's named memory taxonomy (see src/memory/taxonomy.ts) with live\n * availability. Answers \"what do you remember, and how?\" with the honest map of\n * the nine real memory subsystems — including the emotional/drive type that no\n * competitor has. Backs the v7.0 Memory panel and counters the field's\n * \"N memory types\" marketing with a real, drive-backed taxonomy.\n */\nimport { registerSkill } from '../registry.js';\nimport { summarizeMemoryTaxonomy, renderMemoryTaxonomy } from '../../memory/taxonomy.js';\nimport { loadConfig } from '../../config/config.js';\nimport logger from '../../utils/logger.js';\n\nconst COMPONENT = 'MemoryMap';\n\nexport function registerMemoryMapSkill(): void {\n    registerSkill(\n        { name: 'memory_map', description: \"Describe TITAN's named memory taxonomy and which types are active\", version: '1.0.0', source: 'bundled', enabled: true },\n        {\n            name: 'memory_map',\n            description:\n                \"Describe TITAN's MEMORY TAXONOMY — the nine named memory types (working, episodic, semantic, procedural, emotional/drive, prospective, relational, narrative, shared), what each captures, the real subsystem backing it, and whether it's active right now.\\n\\n\" +\n                'USE THIS WHEN: \"what do you remember?\", \"what kinds of memory do you have?\", \"what\\'s your memory architecture?\", or to explain how TITAN persists context across turns and sessions.',\n            parameters: { type: 'object', properties: {}, required: [] },\n            execute: async (): Promise<string> => {\n                try {\n                    const config = loadConfig() as unknown as Record<string, unknown>;\n                    let hindsightConnected = false;\n                    try {\n                        const { memory } = await import('../../memory/facade.js');\n                        hindsightConnected = Boolean(await memory.episodic.isCrossSessionConnected());\n                    } catch { /* Hindsight optional */ }\n                    const summary = summarizeMemoryTaxonomy(config, { hindsightConnected });\n                    logger.info(COMPONENT, `Memory taxonomy: ${summary.active}/${summary.total} types active`);\n                    return renderMemoryTaxonomy(summary);\n                } catch (e) {\n                    return `Failed to summarize memory taxonomy: ${(e as Error).message}`;\n                }\n            },\n        },\n    );\n}\n"],"mappings":";AASA,SAAS,qBAAqB;AAC9B,SAAS,yBAAyB,4BAA4B;AAC9D,SAAS,kBAAkB;AAC3B,OAAO,YAAY;AAEnB,MAAM,YAAY;AAEX,SAAS,yBAA+B;AAC3C;AAAA,IACI,EAAE,MAAM,cAAc,aAAa,qEAAqE,SAAS,SAAS,QAAQ,WAAW,SAAS,KAAK;AAAA,IAC3J;AAAA,MACI,MAAM;AAAA,MACN,aACI;AAAA;AAAA;AAAA,MAEJ,YAAY,EAAE,MAAM,UAAU,YAAY,CAAC,GAAG,UAAU,CAAC,EAAE;AAAA,MAC3D,SAAS,YAA6B;AAClC,YAAI;AACA,gBAAM,SAAS,WAAW;AAC1B,cAAI,qBAAqB;AACzB,cAAI;AACA,kBAAM,EAAE,OAAO,IAAI,MAAM,OAAO,wBAAwB;AACxD,iCAAqB,QAAQ,MAAM,OAAO,SAAS,wBAAwB,CAAC;AAAA,UAChF,QAAQ;AAAA,UAA2B;AACnC,gBAAM,UAAU,wBAAwB,QAAQ,EAAE,mBAAmB,CAAC;AACtE,iBAAO,KAAK,WAAW,oBAAoB,QAAQ,MAAM,IAAI,QAAQ,KAAK,eAAe;AACzF,iBAAO,qBAAqB,OAAO;AAAA,QACvC,SAAS,GAAG;AACR,iBAAO,wCAAyC,EAAY,OAAO;AAAA,QACvE;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AACJ;","names":[]}

package/dist/skills/builtin/reminders.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { registerSkill } from "../registry.js";
+import { addReminder, listReminders, cancelReminder } from "../../agent/reminders.js";
+function registerReminderSkill() {
+  registerSkill(
+    {
+      name: "reminder",
+      description: "Set, list, and cancel reminders that TITAN delivers to the user at a specific time.",
+      version: "1.0.0",
+      source: "bundled",
+      enabled: true
+    },
+    {
+      name: "reminder",
+      description: [
+        "Set, list, or cancel personal reminders. TITAN delivers the reminder to the user at the right time (the mascot announces it on the desk).",
+        "",
+        `USE THIS when the user says: "remind me to X at/on Y", "don't let me forget X", "ping me Friday about X". This is the ONLY correct way to set a reminder \u2014 never claim a reminder is set without calling this.`,
+        'NOT for recurring jobs ("every morning", "daily at 9") \u2192 use the `cron` tool for those.',
+        "",
+        "ACTIONS:",
+        '  \u2022 set    \u2014 message (what to say) + a time. For RELATIVE asks ("in 20 minutes", "in 2 hours") pass inMinutes (a number) \u2014 do NOT compute ISO yourself. For ABSOLUTE times ("Friday 5pm") pass when as ISO 8601 WITH the local timezone offset from your date/time context (e.g. "2026-06-12T17:00:00-07:00").',
+        "  \u2022 list   \u2014 pending reminders.",
+        '  \u2022 cancel \u2014 id (from list), or "all" to clear pending.',
+        "",
+        "Returns the saved reminder with its exact local fire time \u2014 confirm THAT time back to the user."
+      ].join("\n"),
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["set", "list", "cancel"], description: "What to do." },
+          message: { type: "string", description: "set: what to remind the user about." },
+          when: { type: "string", description: "set (absolute): ISO 8601 datetime with timezone offset." },
+          inMinutes: { type: "number", description: 'set (relative): fire this many minutes from now. Preferred for "in N minutes/hours" asks.' },
+          id: { type: "string", description: 'cancel: reminder id, or "all".' }
+        },
+        required: ["action"]
+      },
+      execute: async (args) => {
+        const action = String(args.action ?? "");
+        if (action === "set") {
+          const inMinutes = Number(args.inMinutes);
+          const whenIso = Number.isFinite(inMinutes) && inMinutes > 0 ? new Date(Date.now() + inMinutes * 6e4).toISOString() : String(args.when ?? "");
+          const result = addReminder(String(args.message ?? ""), whenIso);
+          if ("error" in result) return `Error: ${result.error}`;
+          const local = new Date(result.dueAt).toLocaleString();
+          return `Reminder set (id: ${result.id}): "${result.message}" \u2014 I'll tell you on ${local}.`;
+        }
+        if (action === "list") {
+          const pending = listReminders();
+          if (pending.length === 0) return "No pending reminders.";
+          return pending.map((r) => `${r.id} \u2014 "${r.message}" at ${new Date(r.dueAt).toLocaleString()}`).join("\n");
+        }
+        if (action === "cancel") {
+          const id = String(args.id ?? "");
+          if (!id) return 'Error: provide id (or "all").';
+          return cancelReminder(id) ? `Cancelled ${id}.` : `No pending reminder matched "${id}".`;
+        }
+        return "Error: action must be set, list, or cancel.";
+      }
+    }
+  );
+}
+export {
+  registerReminderSkill
+};
+//# sourceMappingURL=reminders.js.map

package/dist/skills/builtin/reminders.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/skills/builtin/reminders.ts"],"sourcesContent":["/**\n * Reminder skill — the tool models were hallucinating (v7.0).\n *\n * \"Remind me Friday at 5pm to buy charcoal\" now has a real, verifiable path:\n * action=set persists a reminder; a 60s daemon watcher fires it through the\n * heartbeat channel so the mascot says it (and any heartbeat consumer shows\n * it). The system prompt always carries the current local date+time, so the\n * model converts natural language (\"Friday 5pm\") to ISO itself.\n */\nimport { registerSkill } from '../registry.js';\nimport { addReminder, listReminders, cancelReminder } from '../../agent/reminders.js';\n\nexport function registerReminderSkill(): void {\n    registerSkill(\n        {\n            name: 'reminder',\n            description: 'Set, list, and cancel reminders that TITAN delivers to the user at a specific time.',\n            version: '1.0.0',\n            source: 'bundled',\n            enabled: true,\n        },\n        {\n            name: 'reminder',\n            description: [\n                'Set, list, or cancel personal reminders. TITAN delivers the reminder to the user at the right time (the mascot announces it on the desk).',\n                '',\n                'USE THIS when the user says: \"remind me to X at/on Y\", \"don\\'t let me forget X\", \"ping me Friday about X\". This is the ONLY correct way to set a reminder — never claim a reminder is set without calling this.',\n                'NOT for recurring jobs (\"every morning\", \"daily at 9\") → use the `cron` tool for those.',\n                '',\n                'ACTIONS:',\n                '  • set    — message (what to say) + a time. For RELATIVE asks (\"in 20 minutes\", \"in 2 hours\") pass inMinutes (a number) — do NOT compute ISO yourself. For ABSOLUTE times (\"Friday 5pm\") pass when as ISO 8601 WITH the local timezone offset from your date/time context (e.g. \"2026-06-12T17:00:00-07:00\").',\n                '  • list   — pending reminders.',\n                '  • cancel — id (from list), or \"all\" to clear pending.',\n                '',\n                'Returns the saved reminder with its exact local fire time — confirm THAT time back to the user.',\n            ].join('\\n'),\n            parameters: {\n                type: 'object',\n                properties: {\n                    action: { type: 'string', enum: ['set', 'list', 'cancel'], description: 'What to do.' },\n                    message: { type: 'string', description: 'set: what to remind the user about.' },\n                    when: { type: 'string', description: 'set (absolute): ISO 8601 datetime with timezone offset.' },\n                    inMinutes: { type: 'number', description: 'set (relative): fire this many minutes from now. Preferred for \"in N minutes/hours\" asks.' },\n                    id: { type: 'string', description: 'cancel: reminder id, or \"all\".' },\n                },\n                required: ['action'],\n            },\n            execute: async (args: Record<string, unknown>): Promise<string> => {\n                const action = String(args.action ?? '');\n                if (action === 'set') {\n                    const inMinutes = Number(args.inMinutes);\n                    const whenIso = Number.isFinite(inMinutes) && inMinutes > 0\n                        ? new Date(Date.now() + inMinutes * 60_000).toISOString()\n                        : String(args.when ?? '');\n                    const result = addReminder(String(args.message ?? ''), whenIso);\n                    if ('error' in result) return `Error: ${result.error}`;\n                    const local = new Date(result.dueAt).toLocaleString();\n                    return `Reminder set (id: ${result.id}): \"${result.message}\" — I'll tell you on ${local}.`;\n                }\n                if (action === 'list') {\n                    const pending = listReminders();\n                    if (pending.length === 0) return 'No pending reminders.';\n                    return pending.map(r => `${r.id} — \"${r.message}\" at ${new Date(r.dueAt).toLocaleString()}`).join('\\n');\n                }\n                if (action === 'cancel') {\n                    const id = String(args.id ?? '');\n                    if (!id) return 'Error: provide id (or \"all\").';\n                    return cancelReminder(id) ? `Cancelled ${id}.` : `No pending reminder matched \"${id}\".`;\n                }\n                return 'Error: action must be set, list, or cancel.';\n            },\n        },\n    );\n}\n"],"mappings":";AASA,SAAS,qBAAqB;AAC9B,SAAS,aAAa,eAAe,sBAAsB;AAEpD,SAAS,wBAA8B;AAC1C;AAAA,IACI;AAAA,MACI,MAAM;AAAA,MACN,aAAa;AAAA,MACb,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,SAAS;AAAA,IACb;AAAA,IACA;AAAA,MACI,MAAM;AAAA,MACN,aAAa;AAAA,QACT;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACJ,EAAE,KAAK,IAAI;AAAA,MACX,YAAY;AAAA,QACR,MAAM;AAAA,QACN,YAAY;AAAA,UACR,QAAQ,EAAE,MAAM,UAAU,MAAM,CAAC,OAAO,QAAQ,QAAQ,GAAG,aAAa,cAAc;AAAA,UACtF,SAAS,EAAE,MAAM,UAAU,aAAa,sCAAsC;AAAA,UAC9E,MAAM,EAAE,MAAM,UAAU,aAAa,0DAA0D;AAAA,UAC/F,WAAW,EAAE,MAAM,UAAU,aAAa,4FAA4F;AAAA,UACtI,IAAI,EAAE,MAAM,UAAU,aAAa,iCAAiC;AAAA,QACxE;AAAA,QACA,UAAU,CAAC,QAAQ;AAAA,MACvB;AAAA,MACA,SAAS,OAAO,SAAmD;AAC/D,cAAM,SAAS,OAAO,KAAK,UAAU,EAAE;AACvC,YAAI,WAAW,OAAO;AAClB,gBAAM,YAAY,OAAO,KAAK,SAAS;AACvC,gBAAM,UAAU,OAAO,SAAS,SAAS,KAAK,YAAY,IACpD,IAAI,KAAK,KAAK,IAAI,IAAI,YAAY,GAAM,EAAE,YAAY,IACtD,OAAO,KAAK,QAAQ,EAAE;AAC5B,gBAAM,SAAS,YAAY,OAAO,KAAK,WAAW,EAAE,GAAG,OAAO;AAC9D,cAAI,WAAW,OAAQ,QAAO,UAAU,OAAO,KAAK;AACpD,gBAAM,QAAQ,IAAI,KAAK,OAAO,KAAK,EAAE,eAAe;AACpD,iBAAO,qBAAqB,OAAO,EAAE,OAAO,OAAO,OAAO,6BAAwB,KAAK;AAAA,QAC3F;AACA,YAAI,WAAW,QAAQ;AACnB,gBAAM,UAAU,cAAc;AAC9B,cAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,iBAAO,QAAQ,IAAI,OAAK,GAAG,EAAE,EAAE,YAAO,EAAE,OAAO,QAAQ,IAAI,KAAK,EAAE,KAAK,EAAE,eAAe,CAAC,EAAE,EAAE,KAAK,IAAI;AAAA,QAC1G;AACA,YAAI,WAAW,UAAU;AACrB,gBAAM,KAAK,OAAO,KAAK,MAAM,EAAE;AAC/B,cAAI,CAAC,GAAI,QAAO;AAChB,iBAAO,eAAe,EAAE,IAAI,aAAa,EAAE,MAAM,gCAAgC,EAAE;AAAA,QACvF;AACA,eAAO;AAAA,MACX;AAAA,IACJ;AAAA,EACJ;AACJ;","names":[]}

package/dist/skills/builtin/spec.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import { registerSkill } from "../registry.js";
+import {
+  readGoalSpec,
+  writeGoalSpec,
+  setAcceptance,
+  renderSpecMd,
+  specReadiness
+} from "../../agent/goalSpec.js";
+import { listSessionGoals } from "../../agent/autonomyContext.js";
+import logger from "../../utils/logger.js";
+const COMPONENT = "SpecSkill";
+function resolveGoalId(explicit) {
+  if (explicit && explicit.trim()) return { goalId: explicit.trim() };
+  const active = listSessionGoals();
+  if (active.length === 1) return { goalId: active[0].goalId };
+  if (active.length === 0) {
+    return { error: 'No active goal to attach a spec to. Pass an explicit "goalId" (the id of the goal/task this spec describes).' };
+  }
+  const ids = active.map((g) => `${g.goalId} (${g.goalTitle})`).join(", ");
+  return { error: `Multiple goals are active \u2014 pass an explicit "goalId". Active: ${ids}` };
+}
+function asStringArray(v) {
+  if (Array.isArray(v)) return v.map((x) => String(x)).filter((s) => s.trim().length > 0);
+  if (typeof v === "string" && v.trim()) {
+    try {
+      const p = JSON.parse(v);
+      if (Array.isArray(p)) return p.map((x) => String(x));
+    } catch {
+    }
+    return v.split("\n").map((s) => s.replace(/^[-*]\s*/, "").trim()).filter(Boolean);
+  }
+  return [];
+}
+function registerSpecSkill() {
+  registerSkill(
+    { name: "spec", description: "Author and check a goal's definition-of-done (spec + acceptance criteria)", version: "1.0.0", source: "bundled", enabled: true },
+    {
+      name: "spec",
+      description: `Spec-driven workflow: write and check a goal's DEFINITION OF DONE (problem, requirements, testable acceptance criteria). The spec is persisted and re-shown to you every turn so you work against it.
+
+actions:
+\u2022 define \u2014 create/replace the spec. Args: problem, requirements[], acceptance[] (each a testable statement), constraints[], nonGoals[], title?. Acceptance items auto-get ids ac1, ac2, \u2026
+\u2022 get \u2014 show the current spec (markdown).
+\u2022 check \u2014 mark one acceptance criterion. Args: criterionId (e.g. "ac1"), status ("met"|"unmet"|"unknown"), evidence? (a test name / observation).
+\u2022 status \u2014 readiness rollup (met/total, %). A goal is only DONE when every criterion is 'met'.
+
+USE THIS WHEN starting non-trivial work ("define done first"), and before declaring a task complete (check every criterion with evidence). goalId is optional \u2014 auto-resolves to the active goal.`,
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["define", "get", "check", "status"], description: "What to do." },
+          goalId: { type: "string", description: "Goal/task id this spec belongs to. Optional \u2014 auto-resolves to the active goal." },
+          title: { type: "string", description: "(define) Short title for the spec." },
+          problem: { type: "string", description: "(define) One-paragraph problem / desired outcome." },
+          requirements: { type: "array", items: { type: "string" }, description: "(define) What the solution must do." },
+          acceptance: { type: "array", items: { type: "string" }, description: '(define) Testable "done" statements. Auto-ided ac1..acN.' },
+          constraints: { type: "array", items: { type: "string" }, description: "(define) Hard limits (perf/security/scope)." },
+          nonGoals: { type: "array", items: { type: "string" }, description: "(define) Explicitly out of scope." },
+          criterionId: { type: "string", description: '(check) Which acceptance criterion, e.g. "ac1".' },
+          status: { type: "string", enum: ["met", "unmet", "unknown"], description: "(check) New status for the criterion." },
+          evidence: { type: "string", description: "(check) How you know \u2014 a test name, log line, observation." }
+        },
+        required: ["action"]
+      },
+      execute: async (args) => {
+        const action = String(args.action || "").toLowerCase();
+        const { goalId, error } = resolveGoalId(args.goalId);
+        if (error) return error;
+        const gid = goalId;
+        try {
+          switch (action) {
+            case "define": {
+              const acceptanceTexts = asStringArray(args.acceptance);
+              const spec = {
+                goalId: gid,
+                title: String(args.title || readGoalSpec(gid)?.title || gid),
+                problem: String(args.problem || ""),
+                requirements: asStringArray(args.requirements),
+                acceptance: acceptanceTexts.map((text, i) => ({ id: `ac${i + 1}`, text, status: "unmet" })),
+                constraints: asStringArray(args.constraints),
+                nonGoals: asStringArray(args.nonGoals),
+                createdAt: readGoalSpec(gid)?.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+                updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+              };
+              writeGoalSpec(spec);
+              const r = specReadiness(spec);
+              return `Spec defined for goal ${gid}: ${spec.acceptance.length} acceptance criteria (${r.met}/${r.total} met). Re-shown each turn \u2014 check criteria with action=check as you satisfy them.
+
+${renderSpecMd(spec)}`;
+            }
+            case "get": {
+              const spec = readGoalSpec(gid);
+              if (!spec) return `No spec exists for goal ${gid} yet. Create one with action=define.`;
+              return renderSpecMd(spec);
+            }
+            case "check": {
+              const critId = String(args.criterionId || "").trim();
+              const status = String(args.status || "").toLowerCase();
+              if (!critId) return 'check requires "criterionId" (e.g. "ac1").';
+              if (!["met", "unmet", "unknown"].includes(status)) return 'check requires "status" of met | unmet | unknown.';
+              const spec = readGoalSpec(gid);
+              if (!spec) return `No spec exists for goal ${gid}. Create one with action=define first.`;
+              const updated = setAcceptance(gid, critId, status, args.evidence);
+              if (!updated) {
+                const ids = spec.acceptance.map((a) => a.id).join(", ") || "(none)";
+                return `No criterion "${critId}" in goal ${gid}'s spec. Known criteria: ${ids}.`;
+              }
+              const r = specReadiness(updated);
+              return `Marked ${critId} = ${status}${args.evidence ? ` (evidence: ${args.evidence})` : ""}. Acceptance now ${r.met}/${r.total} met (${r.pct}%).${r.ready ? " \u2705 All criteria met \u2014 spec is satisfied." : ""}`;
+            }
+            case "status": {
+              const spec = readGoalSpec(gid);
+              if (!spec) return `No spec exists for goal ${gid} yet. Create one with action=define.`;
+              const r = specReadiness(spec);
+              const lines = [`Spec readiness for goal ${gid}: ${r.met}/${r.total} met (${r.pct}%)${r.ready ? " \u2014 \u2705 READY" : ""}`];
+              for (const a of spec.acceptance) {
+                const mark = a.status === "met" ? "\u2705" : a.status === "unknown" ? "\u2753" : "\u2B1C";
+                lines.push(`  ${mark} ${a.id}: ${a.text}${a.evidence ? ` \u2014 ${a.evidence}` : ""}`);
+              }
+              if (!r.ready && r.total > 0) lines.push(`
+NOT done \u2014 ${r.unmet + r.unknown} criteri${r.unmet + r.unknown === 1 ? "on" : "a"} still open.`);
+              return lines.join("\n");
+            }
+            default:
+              return `Unknown spec action "${action}". Use define | get | check | status.`;
+          }
+        } catch (e) {
+          logger.warn(COMPONENT, `spec ${action} failed: ${e.message}`);
+          return `spec ${action} failed: ${e.message}`;
+        }
+      }
+    }
+  );
+}
+export {
+  registerSpecSkill
+};
+//# sourceMappingURL=spec.js.map

package/dist/skills/builtin/spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/skills/builtin/spec.ts"],"sourcesContent":["/**\n * TITAN — Spec-driven workflow skill (v7.0)\n *\n * Exposes the `spec` tool so the agent (or a human via the API) can author and\n * check a goal's **definition of done**: problem statement, requirements, and\n * testable acceptance criteria. The spec is persisted as `spec.md` next to the\n * goal's `plan.md` and re-injected into the prompt every turn (see\n * `src/agent/goalSpec.ts` + `agent.ts` recency-position wiring).\n *\n * The 2026 spec-engineering loop this enables:\n *   1. `spec` action=define  — write the problem + acceptance criteria up front.\n *   2. … agent does the work, reciting the spec each turn …\n *   3. `spec` action=check   — mark each criterion met/unmet WITH evidence.\n *   4. `spec` action=status  — only \"done\" when 100% of criteria are `met`.\n *\n * Complements `goalPlanFile` (the step ladder) — spec is \"are we there?\",\n * plan is \"what's next?\".\n */\nimport { registerSkill } from '../registry.js';\nimport {\n    readGoalSpec, writeGoalSpec, setAcceptance, renderSpecMd, specReadiness,\n    type GoalSpec, type AcceptanceStatus,\n} from '../../agent/goalSpec.js';\nimport { listSessionGoals } from '../../agent/autonomyContext.js';\nimport logger from '../../utils/logger.js';\n\nconst COMPONENT = 'SpecSkill';\n\n/**\n * Resolve which goal the spec action targets. Explicit `goalId` wins; otherwise\n * auto-resolve when exactly one goal session is active. Returns `{ error }` with\n * guidance when ambiguous so the agent gets a clear next step instead of a throw.\n */\nfunction resolveGoalId(explicit?: string): { goalId?: string; error?: string } {\n    if (explicit && explicit.trim()) return { goalId: explicit.trim() };\n    const active = listSessionGoals();\n    if (active.length === 1) return { goalId: active[0].goalId };\n    if (active.length === 0) {\n        return { error: 'No active goal to attach a spec to. Pass an explicit \"goalId\" (the id of the goal/task this spec describes).' };\n    }\n    const ids = active.map((g) => `${g.goalId} (${g.goalTitle})`).join(', ');\n    return { error: `Multiple goals are active — pass an explicit \"goalId\". Active: ${ids}` };\n}\n\n/** Coerce a loose array-of-strings arg (the LLM may send a JSON string). */\nfunction asStringArray(v: unknown): string[] {\n    if (Array.isArray(v)) return v.map((x) => String(x)).filter((s) => s.trim().length > 0);\n    if (typeof v === 'string' && v.trim()) {\n        try { const p = JSON.parse(v); if (Array.isArray(p)) return p.map((x) => String(x)); } catch { /* not json */ }\n        return v.split('\\n').map((s) => s.replace(/^[-*]\\s*/, '').trim()).filter(Boolean);\n    }\n    return [];\n}\n\nexport function registerSpecSkill(): void {\n    registerSkill(\n        { name: 'spec', description: \"Author and check a goal's definition-of-done (spec + acceptance criteria)\", version: '1.0.0', source: 'bundled', enabled: true },\n        {\n            name: 'spec',\n            description:\n                \"Spec-driven workflow: write and check a goal's DEFINITION OF DONE (problem, requirements, testable acceptance criteria). The spec is persisted and re-shown to you every turn so you work against it.\\n\\n\" +\n                'actions:\\n' +\n                '• define — create/replace the spec. Args: problem, requirements[], acceptance[] (each a testable statement), constraints[], nonGoals[], title?. Acceptance items auto-get ids ac1, ac2, …\\n' +\n                '• get — show the current spec (markdown).\\n' +\n                '• check — mark one acceptance criterion. Args: criterionId (e.g. \"ac1\"), status (\"met\"|\"unmet\"|\"unknown\"), evidence? (a test name / observation).\\n' +\n                \"• status — readiness rollup (met/total, %). A goal is only DONE when every criterion is 'met'.\\n\\n\" +\n                'USE THIS WHEN starting non-trivial work (\"define done first\"), and before declaring a task complete (check every criterion with evidence). goalId is optional — auto-resolves to the active goal.',\n            parameters: {\n                type: 'object',\n                properties: {\n                    action: { type: 'string', enum: ['define', 'get', 'check', 'status'], description: 'What to do.' },\n                    goalId: { type: 'string', description: 'Goal/task id this spec belongs to. Optional — auto-resolves to the active goal.' },\n                    title: { type: 'string', description: '(define) Short title for the spec.' },\n                    problem: { type: 'string', description: '(define) One-paragraph problem / desired outcome.' },\n                    requirements: { type: 'array', items: { type: 'string' }, description: '(define) What the solution must do.' },\n                    acceptance: { type: 'array', items: { type: 'string' }, description: '(define) Testable \"done\" statements. Auto-ided ac1..acN.' },\n                    constraints: { type: 'array', items: { type: 'string' }, description: '(define) Hard limits (perf/security/scope).' },\n                    nonGoals: { type: 'array', items: { type: 'string' }, description: '(define) Explicitly out of scope.' },\n                    criterionId: { type: 'string', description: '(check) Which acceptance criterion, e.g. \"ac1\".' },\n                    status: { type: 'string', enum: ['met', 'unmet', 'unknown'], description: '(check) New status for the criterion.' },\n                    evidence: { type: 'string', description: '(check) How you know — a test name, log line, observation.' },\n                },\n                required: ['action'],\n            },\n            execute: async (args: Record<string, unknown>): Promise<string> => {\n                const action = String(args.action || '').toLowerCase();\n                const { goalId, error } = resolveGoalId(args.goalId as string | undefined);\n                if (error) return error;\n                const gid = goalId!;\n\n                try {\n                    switch (action) {\n                        case 'define': {\n                            const acceptanceTexts = asStringArray(args.acceptance);\n                            const spec: GoalSpec = {\n                                goalId: gid,\n                                title: String(args.title || readGoalSpec(gid)?.title || gid),\n                                problem: String(args.problem || ''),\n                                requirements: asStringArray(args.requirements),\n                                acceptance: acceptanceTexts.map((text, i) => ({ id: `ac${i + 1}`, text, status: 'unmet' as AcceptanceStatus })),\n                                constraints: asStringArray(args.constraints),\n                                nonGoals: asStringArray(args.nonGoals),\n                                createdAt: readGoalSpec(gid)?.createdAt || new Date().toISOString(),\n                                updatedAt: new Date().toISOString(),\n                            };\n                            writeGoalSpec(spec);\n                            const r = specReadiness(spec);\n                            return `Spec defined for goal ${gid}: ${spec.acceptance.length} acceptance criteria (${r.met}/${r.total} met). Re-shown each turn — check criteria with action=check as you satisfy them.\\n\\n${renderSpecMd(spec)}`;\n                        }\n                        case 'get': {\n                            const spec = readGoalSpec(gid);\n                            if (!spec) return `No spec exists for goal ${gid} yet. Create one with action=define.`;\n                            return renderSpecMd(spec);\n                        }\n                        case 'check': {\n                            const critId = String(args.criterionId || '').trim();\n                            const status = String(args.status || '').toLowerCase() as AcceptanceStatus;\n                            if (!critId) return 'check requires \"criterionId\" (e.g. \"ac1\").';\n                            if (!['met', 'unmet', 'unknown'].includes(status)) return 'check requires \"status\" of met | unmet | unknown.';\n                            const spec = readGoalSpec(gid);\n                            if (!spec) return `No spec exists for goal ${gid}. Create one with action=define first.`;\n                            const updated = setAcceptance(gid, critId, status, args.evidence as string | undefined);\n                            if (!updated) {\n                                const ids = spec.acceptance.map((a) => a.id).join(', ') || '(none)';\n                                return `No criterion \"${critId}\" in goal ${gid}'s spec. Known criteria: ${ids}.`;\n                            }\n                            const r = specReadiness(updated);\n                            return `Marked ${critId} = ${status}${args.evidence ? ` (evidence: ${args.evidence})` : ''}. Acceptance now ${r.met}/${r.total} met (${r.pct}%).${r.ready ? ' ✅ All criteria met — spec is satisfied.' : ''}`;\n                        }\n                        case 'status': {\n                            const spec = readGoalSpec(gid);\n                            if (!spec) return `No spec exists for goal ${gid} yet. Create one with action=define.`;\n                            const r = specReadiness(spec);\n                            const lines = [`Spec readiness for goal ${gid}: ${r.met}/${r.total} met (${r.pct}%)${r.ready ? ' — ✅ READY' : ''}`];\n                            for (const a of spec.acceptance) {\n                                const mark = a.status === 'met' ? '✅' : a.status === 'unknown' ? '❓' : '⬜';\n                                lines.push(`  ${mark} ${a.id}: ${a.text}${a.evidence ? ` — ${a.evidence}` : ''}`);\n                            }\n                            if (!r.ready && r.total > 0) lines.push(`\\nNOT done — ${r.unmet + r.unknown} criteri${r.unmet + r.unknown === 1 ? 'on' : 'a'} still open.`);\n                            return lines.join('\\n');\n                        }\n                        default:\n                            return `Unknown spec action \"${action}\". Use define | get | check | status.`;\n                    }\n                } catch (e) {\n                    logger.warn(COMPONENT, `spec ${action} failed: ${(e as Error).message}`);\n                    return `spec ${action} failed: ${(e as Error).message}`;\n                }\n            },\n        },\n    );\n}\n"],"mappings":"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","names":[]}

package/dist/skills/builtin/widget_gallery.js

@@ -257,20 +257,22 @@ ALWAYS show the top match's name + category to the user before calling gallery_g
     },
     {
       name: "gallery_get",
-      description: `Fetch a single widget template from the gallery by id, with REPLACE_WITH_X placeholders substituted. Returns the canvas-ready React source you can paste into a _____react block.
+      description: `Fetch a single widget template from the gallery by id, with REPLACE_WITH_X placeholders substituted. Use it to INSPECT a template; to actually place the widget, call create_widget \u2014 NOT a _____react fence.
 
-USE WHEN: you just got a template id from gallery_search and now need its source. ALWAYS call gallery_search first to get the id \u2014 never guess a template name.
+USE WHEN: you just got a template id from gallery_search and need to inspect/verify its source. ALWAYS call gallery_search first to get the id \u2014 never guess a template name.
+
+AFTER THIS: call create_widget({ template: "<id>", fill: {...} }) to place it on the user's canvas. create_widget reports whether the canvas actually received it \u2014 a pasted _____react fence cannot confirm delivery and creates duplicates. Never claim a widget is "on the canvas" unless create_widget confirmed delivery.
 
 DO NOT USE FOR:
 - Browsing what's available \u2192 use gallery_search (returns ranked matches with descriptions).
 - Listing every template \u2192 use gallery_list (full catalogue).
-- Generating a brand-new widget that's not in the catalogue \u2192 emit a fresh _____react block directly; do not gallery_get for templates that don't exist.
+- Generating a brand-new widget that's not in the catalogue \u2192 call create_widget with raw source.
 
 Parameters:
 - id (string, required) \u2014 exact template id from gallery_search results.
 - fill (object, optional) \u2014 placeholder substitutions. Keys are the placeholder name WITHOUT the REPLACE_WITH_ prefix (so { "SYMBOL": "AAPL" } substitutes REPLACE_WITH_SYMBOL). Values are escaped automatically for backslash, single quote, and backtick.
 
-Returns: { source: string, size: { width, height }, category, displayName }. source is the full React component with placeholders filled. Drop it inside a _____react block on the next assistant turn.
+Returns: { source: string, size: { width, height }, category, displayName, next }. Follow the \`next\` instruction.
 
 Errors:
 - "Template not found: <id>" \u2014 the id is wrong (typo or stale). Re-run gallery_search to get a fresh id.
@@ -303,7 +305,12 @@ Errors:
           category: t.category,
           defaultSize: t.defaultSize,
           source: sourceWithMeta,
-          placeholders: t.placeholders ?? []
+          placeholders: t.placeholders ?? [],
+          // v7.0 honesty fix: models were pasting the source into a
+          // _____react fence and claiming "it's on your canvas" with
+          // no delivery confirmation. The result itself now routes
+          // them to the verifiable path.
+          next: `Call create_widget({ template: "${t.id}"${fill ? `, fill: ${JSON.stringify(fill)}` : ""} }) NOW to place it \u2014 do NOT paste a _____react fence (it cannot confirm delivery and duplicates). Only claim the widget is on the canvas if create_widget confirms delivery.`
         });
       }
     }