@worca/app 1.2.0 → 1.3.0

package/src/core/ask/turn.mjs

@@ -19,12 +19,16 @@ import { runClaude } from '../claude-runner.mjs';
 import { resolveModelEnv, resolveModelCost, estimateCost, liveCostRates as defaultLiveCostRates } from '../config.mjs';
 import { worcaHome } from '../projects.mjs';
 import { generateTitle } from '../title.mjs';
+import { cleanText } from '../../shared/graph/assemble.mjs';
 import { createTurnReducer } from './events.mjs';
 import { buildAskSpawnOptions, buildMcpConfig, ASK_MCP_SERVER_PATH } from './spawn.mjs';
+import { refreshAskMemoryMount } from './memory-deps.mjs';
 import { validateProposal } from './proposal.mjs';
+import { validateMetricsChange } from './metrics-deps.mjs';
+import { revalidateWorkflowProposal } from './workflow-deps.mjs';
 import { askLimits, ASK_LIMITS } from './limits.mjs';
 import {
-  newAskId, finishMessage, setMessageBlocks, addThreadTotals, updateThread, setThreadTitle,
+  newAskId, finishMessage, setMessageBlocks, addThreadTotals, updateThread, setThreadTitle, listAttachments,
 } from './store.mjs';
 import { recordAskCostDelta } from '../cost-budget.mjs';
 import { setPendingCardComments } from '../diff-comments.mjs';
@@ -41,6 +45,7 @@ class AskTurn extends EventEmitter {
     firstTurn = false, firstText = '', deterministicTitle = null,
     mock = null, attachmentNames = {},
     pinnedScope = null,
+    memoryProject = null,
     deps = {},
   } = {}) {
     super();
@@ -60,13 +65,23 @@ class AskTurn extends EventEmitter {
     this.attachmentNames = attachmentNames || {};
     // #397: {projectKey}|{workspaceId}|null — the user-pinned scope at POST time.
     this.pinnedScope = pinnedScope && typeof pinnedScope === 'object' ? pinnedScope : null;
+    // Native-rules revision (D16): {key, name}|null — the scope set this turn mounts through --add-dir.
+    this.memoryProject = memoryProject && typeof memoryProject === 'object' ? memoryProject : null;
+    this.memoryDir = null;
+    this._wfCards = new Map();        // tool_use id → card id (START → RESULT of one propose_workflow call)
+    this._tracked = new Set();        // pipeline ids minted as progress cards in THIS reply (one card per pipeline)
+    this.extraCostUsd = 0;            // PD2: money the MCP child spent on the workflow classifier, booked by this turn
     this.deps = {
       runClaudeImpl: deps.runClaudeImpl ?? runClaude,
+      memoryMount: deps.memoryMount ?? refreshAskMemoryMount,
       store: {
-        finishMessage, setMessageBlocks, addThreadTotals, updateThread, setThreadTitle,
+        finishMessage, setMessageBlocks, addThreadTotals, updateThread, setThreadTitle, listAttachments,
         ...(deps.store || {}),
       },
       validateProposal: deps.validateProposal ?? validateProposal,
+      revalidateWorkflow: deps.revalidateWorkflow ?? revalidateWorkflowProposal,
+      validateMetricsChange: deps.validateMetricsChange ?? validateMetricsChange,
+      trackRun: deps.trackRun ?? null,
       generateTitle: deps.generateTitle ?? generateTitle,
       askLimits: deps.askLimits ?? askLimits,
       limits: deps.limits ?? ASK_LIMITS,
@@ -88,6 +103,7 @@ class AskTurn extends EventEmitter {
       onOutOfTurn: deps.onOutOfTurn ?? (() => {}),
       onCommentMutation: deps.onCommentMutation ?? (() => {}),
       onWorktreeMutation: deps.onWorktreeMutation ?? (() => {}),
+      onMemoryMutation: deps.onMemoryMutation ?? (() => {}),
       // DISPLAY-ONLY rates for the footer's live "≈" estimate (config.mjs
       // liveCostRates: override → list price → null). Injectable so tests pin
       // the frame arithmetic without the catalog.
@@ -125,6 +141,7 @@ class AskTurn extends EventEmitter {
   }
 
   _persistBlocks() {
+    if (this._completed) return;                                  // v7: after _complete() the terminal write owns the row
     // R-A: the card (and every mid-turn notice) must survive a server restart
     // and be visible to findCard/updateCardBlock while the turn streams.
     try { this.deps.store.setMessageBlocks(this.assistantMessageId, this.reducer.snapshot().blocks); }
@@ -143,7 +160,11 @@ class AskTurn extends EventEmitter {
       || (typeof raw.workspaceId === 'string' && raw.workspaceId.trim());
     const inp = pin && !hasTarget ? { ...raw, ...pin } : raw;
     try {
-      const r = await d.validateProposal(inp, { cardId });
+      // The thread's attachment ledger, so attachmentIds the model cites resolve
+      // to real rows (spec §6.4). A ledger failure never blocks the card.
+      let attachments = [];
+      try { attachments = (typeof d.store.listAttachments === 'function' && d.store.listAttachments(this.threadId)) || []; } catch { attachments = []; }
+      const r = await d.validateProposal(inp, { cardId, attachments });
       if (r && r.ok) {
         // #397 guardrail: a proposal targeting a DIFFERENT project/workspace than
         // the pinned one is accepted but flagged — the card renders the mismatch
@@ -168,7 +189,123 @@ class AskTurn extends EventEmitter {
     this._persistBlocks();
   }
 
+  /** track_run's card (D3/D4): the MCP child only resolved the id — deps.trackRun (ui/server.mjs askTrackRun)
+   *  links the run to this thread and follows a live one; this mints ONE stateless progress card per pipeline
+   *  per reply (older replies keep theirs — every card derives what it shows). */
+  async _onTrackRun(input, isError) {
+    if (isError) return;
+    const d = this.deps;
+    if (typeof d.trackRun !== 'function') return;
+    const raw = input && typeof input === 'object' ? input : {};
+    let r = null;
+    try { r = await d.trackRun(raw, { threadId: this.threadId, pin: this.pinnedScope }); }
+    catch (err) { r = { ok: false, error: err?.message || String(err) }; }
+    if (!r || !r.ok || !r.card || !r.card.pipelineId) {
+      this.reducer.addBlock({ kind: 'notice', text: `Could not track the run: ${(r && r.error) || 'unknown error'}` });
+      this._persistBlocks();
+      return;
+    }
+    if (this._tracked.has(r.card.pipelineId)) return;          // the hook continuations run one at a time after their await
+    this._tracked.add(r.card.pipelineId);
+    const block = this.reducer.addBlock({ kind: 'card', id: d.newAskId('card'), state: 'tracked', card: r.card });
+    if (!block) return;                                          // null after finish() (events.mjs:511) — _onWorkflowResult's own guard
+    this._persistBlocks();                                       // a store write; the browser gets the reducer's ask-card frame
+  }
+
+  /**
+   * propose_metrics_change RESULT: the child validated for the model's self-correction; the parent re-validates the
+   * same INPUT authoritatively (metrics-proposal.mjs is pure over the real readers) and mints the card. An isError
+   * result or a child {ok:false} already reached the model as text — no card, no notice.
+   */
+  async _onMetricsProposal(input, text, isError) {
+    if (isError) return;
+    let out = null;
+    try { out = JSON.parse(text); } catch { out = null; }
+    if (!out || out.ok !== true) return;
+    const d = this.deps;
+    const raw = input && typeof input === 'object' ? input : {};
+    // The child's pinned-scope default, replayed (tools.mjs propose_metrics_change): the card matches what the model saw.
+    const pin = this.pinnedScope;
+    const kind = typeof raw.kind === 'string' ? raw.kind.trim() : '';
+    let inp = raw;
+    if (pin && !(typeof raw.projectKey === 'string' && raw.projectKey.trim()) && !(typeof raw.workspaceId === 'string' && raw.workspaceId.trim())) {
+      if (pin.projectKey && (kind === 'enable' || kind === 'record')) inp = { ...raw, projectKey: pin.projectKey };
+      if (pin.workspaceId && (kind === 'workspace_home' || kind === 'route_members')) inp = { ...raw, workspaceId: pin.workspaceId };
+    }
+    try {
+      const r = await d.validateMetricsChange(inp);
+      if (r && r.ok) this.reducer.addBlock({ kind: 'card', id: d.newAskId('card'), state: 'proposed', card: r.card });
+      else {
+        const errors = (r && Array.isArray(r.errors) && r.errors.length) ? r.errors : ['invalid proposal'];
+        this.reducer.addBlock({ kind: 'notice', text: `Metrics change rejected: ${errors.join('; ')}` });
+      }
+    } catch (err) {
+      this.reducer.addBlock({ kind: 'notice', text: `Metrics change rejected: ${err?.message || err}` });
+    }
+    this._persistBlocks();
+  }
+
+  /** The card exists from the tool_use on (spec §8.2, PD7): a building block with the four-step trace, persisted. */
+  _onWorkflowStart(toolUseId, input) {
+    const d = this.deps;
+    const cardId = d.newAskId('card');
+    this._wfCards.set(toolUseId, cardId);
+    const raw = input && typeof input === 'object' ? input : {};
+    const pin = this.pinnedScope;
+    // A pinned WORKSPACE is not a default target (D19/PD17): the building card then carries projectKey null and the child's
+    // own "projectKey is required" error flips it to failed at RESULT.
+    const projectKey = (typeof raw.projectKey === 'string' && raw.projectKey.trim()) || (pin && pin.projectKey) || null;
+    const mode = typeof raw.task === 'string' && raw.task.trim() ? 'task' : 'shape';
+    this.reducer.addBlock({ kind: 'card', id: cardId, state: 'building', card: {
+      type: 'workflow', mode, projectKey, projectName: null,
+      // v7: the building payload is transient (the proposed flip replaces `card` wholesale) — cap a hand-authored shape like the task text.
+      ...(mode === 'task' ? { task: String(raw.task).slice(0, 2000) } : { shape: raw.shape && typeof raw.shape === 'object' && JSON.stringify(raw.shape).length <= 8000 ? raw.shape : null }),
+      name: cleanText(raw.name, 60), note: cleanText(raw.note, d.limits.workflowNoteMaxChars ?? 200), thenRun: raw.thenRun === true,
+      trace: { step: 1, startedAt: new Date(d.now()).toISOString() },
+    } });
+    this._persistBlocks();
+  }
+
+  /** RESULT: re-validate the returned shape in the parent (assemble, validateGraph, match, buildProposal) and flip the block. */
+  async _onWorkflowResult(toolUseId, text, isError) {
+    const d = this.deps;
+    const cardId = this._wfCards.get(toolUseId);
+    if (!cardId) return;
+    this._wfCards.delete(toolUseId);
+    const fail = (reason) => this.reducer.updateBlock(cardId, { state: 'failed', error: cleanText(reason, 300) || 'proposal failed' });
+    let out = null;
+    if (!isError) { try { out = JSON.parse(text); } catch { out = null; } }
+    // PD2: the classifier ran in the child whatever happens next — book its spend BEFORE judging the result. v7: a
+    // {ok:false, error, costUsd} result (classifier timeout / two unusable replies / a shape still rejected after the retry)
+    // carries what the failed attempts cost (ClassifierError.costUsd); v6 booked only on ok:true and lost it.
+    if (out && Number(out.costUsd) > 0) this.extraCostUsd += Number(out.costUsd);
+    if (isError || !out || out.ok !== true || !out.shape || typeof out.shape !== 'object') {
+      const reason = isError ? String(text ?? '').replace(/^error:\s*/, '') : (out && typeof out.error === 'string' && out.error) || 'the tool returned no shape';
+      if (!fail(reason)) return;                                  // null: the reducer is finished (stop/timeout) — the terminal write already happened
+      this._persistBlocks();
+      return;
+    }
+    try {
+      const r = await d.revalidateWorkflow({ shape: out.shape, projectKey: out.projectKey, warnings: Array.isArray(out.warnings) ? out.warnings : [], costUsd: Number(out.costUsd) || 0, fingerprint: typeof out.fingerprint === 'string' ? out.fingerprint : '' });
+      // v4: the child's projectName first (the real child resolves it), else the parent's own lookup (the MOCK child
+      // returns null — without this every mock card, and its context-header line, would have no project name).
+      const projectName = cleanText(out.projectName, 120) || cleanText(r.project && r.project.name, 120) || null;
+      const flipped = this.reducer.updateBlock(cardId, { state: 'proposed', card: {
+        type: 'workflow', mode: out.mode === 'shape' ? 'shape' : 'task', projectKey: typeof out.projectKey === 'string' ? out.projectKey : null,
+        projectName, note: cleanText(out.note, 200), thenRun: out.thenRun === true,
+        shape: r.shape, summary: cleanText(r.summary, 2000),
+        ...r.proposal,
+      } });
+      if (!flipped) return;                                       // v7: finished reducer (the turn was stopped mid-revalidate) — never persist a stale snapshot
+    } catch (err) {
+      if (!fail(err && err.message ? err.message : String(err))) return;
+    }
+    this._persistBlocks();
+  }
+
   _makeReducer() {
+    this._wfCards.clear();
+    this._tracked.clear();
     const d = this.deps;
     // One settings read per attempt, never per frame. null → the frames carry
     // estimatedCostUsd:null and the footer keeps today's behaviour.
@@ -188,12 +325,18 @@ class AskTurn extends EventEmitter {
       resolveCost: (cliCostUsd, usage) => d.resolveModelCost(this.model, cliCostUsd, usage),
       limits: d.limits,
       onProposal: ({ input }) => this._onProposal(input),
+      onWorkflowStart: ({ toolUseId, input }) => this._onWorkflowStart(toolUseId, input),
+      onWorkflowResult: ({ toolUseId, text, isError }) => this._onWorkflowResult(toolUseId, text, isError),   // the hook's `input` is not needed here: the card is rebuilt from `out`
+      onTrackRun: ({ input, isError }) => this._onTrackRun(input, isError),
+      onMetricsProposal: ({ input, text, isError }) => this._onMetricsProposal(input, text, isError),
       // The MCP child cannot broadcast; the parent turns its comment writes into
       // the same poke the REST routes emit.
       onCommentMutation: (e) => { try { this.deps.onCommentMutation(e); } catch { /* a broken sink never breaks the turn */ } },
       // Same shape for worktrees: open/remove/navigate in the child → the server
       // broadcasts the thread's worktree envelope (ui/server.mjs emitAskWorktrees).
       onWorktreeMutation: (e) => { try { this.deps.onWorktreeMutation(e); } catch { /* a broken sink never breaks the turn */ } },
+      // ...and for memory: a remember/forget in the child becomes the server's memory-changed frame.
+      onMemoryMutation: (e) => { try { this.deps.onMemoryMutation(e); } catch { /* a broken sink never breaks the turn */ } },
       // DISPLAY ONLY — never a sink input: prices the running usage sum (main +
       // sub-agent tokens) at the TURN model's rates; the "≈" in the footer owns
       // that approximation. _complete() reads summary.costUsd, not this.
@@ -228,13 +371,20 @@ class AskTurn extends EventEmitter {
     this._completed = true;
     const d = this.deps;
     await this._settle();
+    // PD7: a card still building when the reply ends can never flip — fail it while the reducer is still open.
+    for (const b of this.reducer.snapshot().blocks) {
+      if (b && b.kind === 'card' && b.state === 'building') this.reducer.updateBlock(b.id, { state: 'failed', error: 'the reply ended before the proposal was ready' });
+    }
     const summary = this.reducer.finish();
     const finalStatus = kind === 'error' ? 'error' : status;
     // Already AUTHORITATIVE: the reducer applied this turn's per-model cost
     // override (the `resolveCost` hook in _makeReducer), so this one value is
     // correct for all four sinks below — the message row, the thread totals, the
     // budget ledger, and the ask-done frame.
-    const costUsd = summary.costUsd;
+    // PD2: the MCP child's classifier spend (propose_workflow task mode) is real money this turn caused — it rides
+    // the SAME figure the four sinks read. No `result` frame (stopped early) still books it: the classifier ran.
+    const extra = Math.round((Number(this.extraCostUsd) || 0) * 1e6) / 1e6;
+    const costUsd = summary.costUsd == null ? (extra > 0 ? extra : null) : Math.round((summary.costUsd + extra) * 1e6) / 1e6;
     // Persist BEFORE broadcasting: a client re-fetch on the terminal frame must
     // never see a still-streaming row. finishMessage gets the FULL patch (B-5).
     try {
@@ -313,6 +463,14 @@ class AskTurn extends EventEmitter {
       // _attempts below is the backstop for a mkdir/write failure, so "fires
       // after ANY terminal status of the first turn" stays true.
       this._kickoffTitle();
+      // Native-rules revision: refresh the chat's memory mount for this turn's scope set and hand
+      // it to the spawn as --add-dir. A store failure never breaks a turn — the turn carries no
+      // memory and says so on the server log (the rules are additive; the chat is unaffected).
+      try { this.memoryDir = await d.memoryMount({ projectKey: this.memoryProject?.key ?? null, projectName: this.memoryProject?.name ?? null }); }
+      catch (err) {
+        this.memoryDir = null;
+        console.warn(`[worca-ask] thread ${this.threadId}: memory mount failed (${err?.message || err}) — this turn carries no memory`);
+      }
       const homeBase = process.env.WORCA_HOME?.trim()
         ? pathResolve(process.env.WORCA_HOME)
         : dirname(d.worcaHome());
@@ -376,6 +534,7 @@ class AskTurn extends EventEmitter {
         limits: limitsNow,
         mcpConfigPath,
         scratchDir,
+        memoryDir: this.memoryDir,
       });
       try {
         await d.runClaudeImpl(options);

package/src/core/ask/workflow-deps.mjs

@@ -0,0 +1,226 @@
+// src/core/ask/workflow-deps.mjs
+// The propose_workflow dependency bundle (auto-workflow-design.md §8.1-8.2, plan P3 PD1/PD8): the ONE module that
+// runs the Auto pipeline outside a run — fingerprint → classifier → assembler → matcher → buildProposal. Two callers:
+//   • the MCP child: tools.mjs propose_workflow → deps.workflow.propose(): classifies / normalizes, assembles, matches,
+//     and RETURNS the normalized shape (the parent cannot see the child's memory — the shape travels in the tool result);
+//   • the parent: turn.mjs _onWorkflowResult and the cards route → revalidateWorkflowProposal(): re-assembles that shape,
+//     re-matches and builds the card payload (buildProposal) — deterministic, so Save re-derives the same template.
+// Reads only (the workflows row is written by the cards route; test/ask-workflow-deps.test.mjs scans this file).
+// Names no agent key (D23). tools.mjs may not import anything, hence every reader/spawner lives here.
+import { join } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import { loadAgentRegistry } from '../agent-registry.mjs';
+import { listProjects, worcaHome } from '../projects.mjs';
+import { listModels, resolveRunConfig } from '../config.mjs';
+import { mockEnabled } from '../claude-runner.mjs';
+import { assembleShape, ShapeError, cleanText, normalizeShape } from '../../shared/graph/assemble.mjs';
+import { fingerprintProject } from '../auto/fingerprint.mjs';
+import { classifyTask, checkShapeModels, ClassifierError } from '../auto/classify.mjs';
+import { autoCandidates, findEquivalentWorkflow } from '../auto/match.mjs';
+import { openRepoLook } from '../auto/repo-look.mjs';
+import { buildProposal, remapTunables } from '../auto/proposal.mjs';
+import { resolveAutoModel } from '../auto/model.mjs';
+import { ASK_LIMITS } from './limits.mjs';
+
+const TUNABLE_KEYS = ['model', 'effort', 'fanOut', 'askQuestions'];
+const flat = (v, max) => cleanText(v, max);
+
+/** {key, name, path} for a project key, or null. */
+export async function projectByKey(key) {
+  if (typeof key !== 'string' || !key) return null;
+  const rows = await listProjects();
+  const p = rows.find((x) => x && x.key === key);
+  return p ? { key: p.key, name: p.name || '', path: p.path } : null;
+}
+
+/** The CLI's proposal vocabulary (src/cli/render.mjs formatWorkflowProposal) as ONE line for the model. */
+export function proposalSummary(proposal) {
+  const nodes = proposal?.manifest?.graph?.nodes || [];
+  const wires = proposal?.manifest?.graph?.wires || [];
+  const labelOf = (id) => nodes.find((n) => n.id === id)?.label || id;
+  const stages = (proposal?.order || []).map((id) => {
+    const n = proposal.nodes?.[id] || {};
+    const tune = [n.model, n.effort].filter(Boolean).join(' · ');
+    return `${n.label || id}${tune ? ` (${tune})` : ''}${n.fanOut ? ' ⤴' : ''}`;
+  });
+  const loops = wires.filter((w) => w.loop && Number.isInteger(w.maxCycles)).map((w) => `${labelOf(w.from.node)} → ${labelOf(w.to.node)} (max ${w.maxCycles} cycles)`);
+  return `stages: ${stages.join(' → ')}${loops.length ? `; loops: ${loops.join(', ')}` : ''}`;
+}
+
+/** Bake accepted tunables into a template's agent node config — a NEW row only (a matched row is never touched).
+ *  '' clears a key (sanitizeProposalAnswer's "model '' clears model AND effort"). */
+export function applyTunables(template, tunables = {}) {
+  return {
+    ...template,
+    nodes: (template.nodes || []).map((n) => {
+      const t = tunables && tunables[n.id];
+      if (!t || n.kind !== 'agent') return n;
+      const config = { ...(n.config || {}) };
+      for (const k of TUNABLE_KEYS) {
+        if (t[k] === undefined) continue;
+        if (t[k] === '') delete config[k]; else config[k] = t[k];
+      }
+      return { ...n, config };
+    }),
+  };
+}
+
+/** Drop model/effort a hand-authored shape names that the catalog does not carry (PD19). Reads a NORMALIZED shape. Returns warnings. */
+function dropUnknownModels(shape, models) {
+  const issues = checkShapeModels(shape, models);
+  if (!issues.length) return [];
+  const warnings = [];
+  const units = (s) => (Array.isArray(s.parallel) ? s.parallel : [s]);
+  for (const st of shape.stages.flatMap(units)) {
+    const hit = issues.filter((i) => i.stageId === st.id);
+    if (!hit.length) continue;
+    const t = st.tunables || st;
+    delete t.model; delete t.effort;
+    warnings.push(`stage ${st.id}: ${hit.map((i) => i.message.replace(/^stage "[^"]*": /, '')).join('; ')} — dropped`);
+  }
+  return warnings;
+}
+
+/**
+ * The deterministic half (spec §8.2): assemble (validateGraph inside), match, buildProposal. Pure w.r.t. the workflows table.
+ * Also resolves the target project (v4): the parent needs its NAME for the card and the context header, and the MCP
+ * child's result may not carry it (the mock never does).
+ * @param {{shape:object, projectKey?:string|null, warnings?:Array, costUsd?:number, fingerprint?:string, models?:Array|null, registry?:object|null}} o
+ * @returns {Promise<{proposal:object, template:object, match:{id,name}|null, tunables:object, shape:object, summary:string, project:{key,name,path}|null}>}
+ * @throws {ShapeError} on an unassemblable shape
+ */
+export async function revalidateWorkflowProposal({ shape, projectKey = null, warnings = [], costUsd = 0, fingerprint = '', models = null, registry = null }) {
+  const reg = registry || loadAgentRegistry();
+  const catalog = models || await listModels('');
+  const built = assembleShape(shape, { registry: reg, humanInLoop: true });
+  const match = findEquivalentWorkflow(built.template, await autoCandidates());
+  const project = await projectByKey(projectKey);          // null for no key / an unknown key — never throws
+  let template = built.template;
+  let tunables = built.tunables;
+  let ignoredProjectOverrides = false;
+  if (match) {
+    tunables = remapTunables(tunables, match.nodeMap);
+    template = match.candidate;
+    if (project) {
+      try {
+        const rc = await resolveRunConfig(project.path, match.candidate.id);
+        ignoredProjectOverrides = Object.keys(rc?.nodes || {}).length > 0 || Object.keys(rc?.wires || {}).length > 0;
+      } catch { ignoredProjectOverrides = false; }
+    }
+  }
+  const proposal = buildProposal({
+    round: 1, shape: built.shape, template,
+    match: match ? { id: match.candidate.id, name: match.candidate.name } : null,
+    tunables, registry: reg, models: catalog,
+    warnings: [...(warnings || []), ...built.warnings], costUsd, fingerprint, ignoredProjectOverrides,
+  });
+  return { proposal, template, match: proposal.match, tunables, shape: built.shape, summary: proposalSummary(proposal), project };
+}
+
+/** `[worca event] …` — the synthetic turn's prompt (spec §8.4). Names are cleaned: they land in a prompt line. v7: the name sits
+ *  inside double quotes that the mock's event regex (and the model) key on, so `"` becomes `'`, and a `[worca context]` /
+ *  `[/worca context]` tag typed into a name is neutralised (prompt.mjs:47-49 does that only for header lines). */
+const eventName = (name) => flat(name, 60).replace(/"/g, "'").replace(/\[(\/?)worca context\]/gi, '($1worca context)');
+export function workflowEventPrompt({ cardId, state, workflowId = null, name = '', thenRun = false, projectKey = '' }) {
+  const p = flat(projectKey, 120);
+  if (state === 'declined') return `[worca event] workflow card ${cardId} declined; project=${p}`;
+  return `[worca event] workflow card ${cardId} saved as ${flat(workflowId, 120)} "${eventName(name)}"; thenRun=${thenRun ? 'true' : 'false'}; project=${p}`;
+}
+
+/** The user-row notice (mockup §C copy). */
+export function workflowNoticeText({ state, name = '', matched = false, thenRun = false }) {
+  const n = flat(name, 60);
+  if (state === 'declined') return `Workflow "${n}" declined`;
+  const head = matched ? `Using your saved workflow "${n}"` : `Workflow "${n}" saved`;
+  return thenRun ? `${head} · Auto will propose a run next` : head;
+}
+
+/**
+ * @param {{threadId?:string|null, signal?:AbortSignal|null, classify?:Function}} [o]
+ *   threadId  unused today (the bundle is thread-agnostic); keeps the *-deps.mjs signature uniform
+ *   signal    the MCP child's lifetime signal (mcp-stdio main() aborts it when stdin closes = the chat turn ended/was stopped) —
+ *             the classifier honours it, so a Stop in the chat no longer leaves a nested claude running for up to 4 × 90 s (v7)
+ *   classify  test seam for the classifier (defaults to classifyTask); tests inject a thrower / a recorder, never a spawn
+ */
+export function defaultWorkflowDeps({ threadId = null, signal = null, classify = classifyTask } = {}) {   // eslint-disable-line no-unused-vars
+  const bundleSignal = signal;
+  return {
+    workflow: {
+      /**
+       * The child-side half. Task mode = the orchestrator's _autoRound (classify, ONE retry on a ShapeError with the issues as
+       * feedback); shape mode = normalize + drop unknown models. Both then run revalidateWorkflowProposal.
+       * Resolves {ok:true,…} — or, in task mode, {ok:false, error, costUsd, mode, projectKey, projectName} when the classifier
+       * failed (timeout / two unusable replies / a shape the assembler still rejects after the retry): the money it spent is
+       * REAL and rides `costUsd` so the parent books it (PD2, v7 — v6 rethrew and lost the spend). Input errors (unknown
+       * project, an unassemblable hand-authored shape: nothing was spent) still THROW and reach the model as tool-error text.
+       * @param {{mode:'task'|'shape', task?:string, shape?:object, name?:string, projectKey:string, note?:string, thenRun?:boolean, signal?:AbortSignal}} o
+       */
+      async propose({ mode, task = '', shape = null, name = '', projectKey, note = '', thenRun = false, signal = null }) {
+        const project = await projectByKey(projectKey);
+        if (!project) throw new Error(`unknown projectKey "${flat(projectKey, 120)}" — call list_projects`);
+        const registry = loadAgentRegistry();
+        const models = await listModels('');
+        const fingerprint = await fingerprintProject(project.path);
+        const warnings = [];
+        let picked;
+        let costUsd = 0;
+        let r;
+        if (mode === 'task') {
+          const cwd = join(worcaHome(), 'tmp', 'ask');           // the ask scratch dir — never the user's checkout (spec §4.5)
+          await mkdir(cwd, { recursive: true });
+          // D6 amendment: the classifier may Read/Grep/Glob a throwaway detached checkout of the
+          // project's HEAD to SIZE the change. Mock never spawns, so it never borrows one; a project
+          // without git (or a failed `git worktree add`) classifies text-only, exactly as before.
+          const look = mockEnabled({}) ? null : await openRepoLook(project.path, cwd, { signal: signal || bundleSignal });
+          const input = {
+            taskText: String(task).slice(0, ASK_LIMITS.workflowTaskMaxChars), extras: [], fingerprint, models, registry, domain: 'coding',
+            humanInLoop: true, feedback: [], priorShape: null, model: resolveAutoModel(models), cwd: look ? look.cwd : cwd, repoLook: !!look,
+            mock: mockEnabled({}), signal: signal || bundleSignal,
+          };
+          // Every failure AFTER money may have been spent resolves {ok:false, costUsd} (v7): ClassifierError carries what its
+          // failed attempts cost (classify.mjs); a ShapeError after the retry means two billed classifier calls.
+          const spent = (err) => ({
+            ok: false, mode, projectKey: project.key, projectName: flat(project.name, 120),
+            error: flat(err && err.message ? err.message : String(err), 300), costUsd: Math.round((costUsd + (Number(err && err.costUsd) || 0)) * 1e6) / 1e6,
+          });
+          try {
+            let classified;
+            try { classified = await classify(input); }
+            catch (err) { if (err instanceof ClassifierError) return spent(err); throw err; }
+            costUsd += Number(classified.costUsd) || 0;
+            warnings.push(...(classified.warnings || []));
+            picked = name ? { ...classified.shape, name } : classified.shape;
+            try {
+              r = await revalidateWorkflowProposal({ shape: picked, projectKey: project.key, warnings, costUsd, fingerprint, models, registry });
+            } catch (err) {
+              if (!(err instanceof ShapeError)) throw err;
+              let again;
+              try {
+                again = await classify({ ...input, priorShape: classified.shape,
+                  feedback: [`The previous shape could not be assembled: ${err.issues.map((i) => i.message).join('; ')}. Fix it and reply with the full shape.`] });
+              } catch (e2) { if (e2 instanceof ClassifierError) return spent(e2); throw e2; }
+              costUsd += Number(again.costUsd) || 0;
+              warnings.push(...(again.warnings || []));
+              picked = name ? { ...again.shape, name } : again.shape;
+              try {
+                r = await revalidateWorkflowProposal({ shape: picked, projectKey: project.key, warnings, costUsd, fingerprint, models, registry });
+              } catch (e3) { if (e3 instanceof ShapeError) return spent(e3); throw e3; }
+            }
+          } finally {
+            if (look) await look.close();                            // the checkout never outlives the call (every `return spent(...)` above passes through here)
+          }
+        } else {
+          picked = normalizeShape(name ? { ...shape, name } : shape);   // throws ShapeError with EVERY issue — the model fixes them in one go
+          warnings.push(...dropUnknownModels(picked, models));
+          r = await revalidateWorkflowProposal({ shape: picked, projectKey: project.key, warnings, costUsd, fingerprint, models, registry });
+        }
+        return {
+          ok: true, mode, projectKey: project.key, projectName: flat(project.name, 120),
+          name: r.proposal.name, match: r.match, warnings: r.proposal.warnings, summary: r.summary,
+          shape: r.shape, costUsd: r.proposal.costUsd, fingerprint, note: flat(note, ASK_LIMITS.workflowNoteMaxChars), thenRun: thenRun === true,
+        };
+      },
+      revalidate: revalidateWorkflowProposal,
+    },
+  };
+}