@worca/app 1.2.0 → 1.3.0

package/src/core/artifacts.mjs

@@ -11,13 +11,15 @@
 import { mkdir, writeFile, readFile, copyFile, readdir } from 'node:fs/promises';
 import { join, basename, resolve, isAbsolute } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { realpathSync, existsSync } from 'node:fs';
+import { realpathSync, existsSync, statSync } from 'node:fs';
 import { hostname } from 'node:os';
 import { projectKey, projectStorePath, canonicalProjectRoot, workspaceStorePath } from './store.mjs';
 import { listProjects } from './projects.mjs';
 import { branchExists, diffShortstat, hasGh, findPrForBranch } from './git-info.mjs';
 import { getDb, tx } from './db.mjs';
 import { RUN_LOG_FILE } from './run-log.mjs';
+import { readRunLedger } from './metrics/ledger.mjs';
+import { memoryTotals } from './memory-sync.mjs';
 
 // ── DB row <-> state object mapping (Phase 3) ──────────────────────────────────
 // JSON columns are TEXT; (de)serialize at THIS boundary only. Reads are fail-safe:
@@ -82,17 +84,27 @@ export function deleteStoreMeta(key) {
  * in plans//reviews/, siblings of pipelines/). Idempotent (INSERT OR IGNORE on the
  * (pipeline_id, kind, rel_path) PK), best-effort: a logging failure never breaks a
  * run. A null/empty path is a no-op. The pipelines row must already exist (FK).
+ * Optional per-step attribution (step_key/node_id/cycle/created_at) is stamped on
+ * the FIRST insert only — the conflict behavior stays byte-for-byte INSERT OR
+ * IGNORE (first write wins), so a re-record never clobbers an existing row's
+ * attribution. The 3-arg form still works (attr defaults to {}, columns NULL).
  * @param {string} pipelineId
  * @param {string} kind
  * @param {string} relPath
+ * @param {{stepKey?:string, nodeId?:string, cycle?:number}} [attr]
  */
-export function recordArtifact(pipelineId, kind, relPath) {
+export function recordArtifact(pipelineId, kind, relPath, attr = {}) {
   if (!pipelineId || !kind || !relPath) return;
+  const stepKey = attr.stepKey ?? null;
+  const nodeId = attr.nodeId ?? null;
+  const cycle = attr.cycle ?? null;
+  const createdAt = new Date().toISOString();
   try {
     tx(() => {
       getDb().prepare(
-        'INSERT OR IGNORE INTO artifacts (pipeline_id, kind, rel_path) VALUES (?, ?, ?)',
-      ).run(pipelineId, kind, relPath);
+        'INSERT OR IGNORE INTO artifacts (pipeline_id, kind, rel_path, step_key, node_id, cycle, created_at) '
+        + 'VALUES (?, ?, ?, ?, ?, ?, ?)',
+      ).run(pipelineId, kind, relPath, stepKey, nodeId, cycle, createdAt);
     });
   } catch { /* artifact indexing is best-effort; never break a run on it */ }
 }
@@ -111,6 +123,53 @@ export async function listArtifacts(pipelineId) {
     .all(pipelineId).map((r) => ({ kind: r.kind, relPath: r.rel_path }));
 }
 
+/**
+ * List a run's artifacts with step attribution and on-disk byte size, ordered
+ * created_at (NULLs first, so legacy rows bucket ahead) then rel_path. `bytes` is
+ * stat-ed run dir first, store root second (mirroring resolveIndexedArtifactForRow's
+ * base order); a missing file reports bytes: 0. Optional { stepKey, kind } filter.
+ * An optional `limit` caps the SQL result so the per-row statSync only runs on
+ * rows the caller keeps (pass limit+1 to detect truncation); omit it to size
+ * every row.
+ * @param {string} pipelineId
+ * @param {{stepKey?:string, kind?:string, limit?:number}} [filter]
+ * @returns {Promise<Array<{kind:string, stepKey:string|null, nodeId:string|null, cycle:number|null, relPath:string, bytes:number, createdAt:string|null}>>}
+ */
+export async function listRunArtifacts(pipelineId, filter = {}) {
+  const row = findPipelineRowById(pipelineId);
+  if (!row) return [];
+  // Query the RESOLVED id: findPipelineRowById accepts a run-dir basename/suffix
+  // (DIR_ID_RE), so `pipelineId` may not equal the stored `pipeline_id`.
+  const clauses = ['pipeline_id = ?'];
+  const args = [row.id];
+  if (filter.stepKey) { clauses.push('step_key = ?'); args.push(filter.stepKey); }
+  if (filter.kind) { clauses.push('kind = ?'); args.push(filter.kind); }
+  const hasLimit = Number.isInteger(filter.limit) && filter.limit > 0;
+  const raw = getDb().prepare(
+    `SELECT kind, rel_path, step_key, node_id, cycle, created_at FROM artifacts
+     WHERE ${clauses.join(' AND ')}
+     ORDER BY (created_at IS NULL) DESC, created_at ASC, rel_path ASC${hasLimit ? ' LIMIT ?' : ''}`,
+  ).all(...args, ...(hasLimit ? [filter.limit] : []));
+  const isWs = row.target === 'workspace' || !!row.workspace_key;
+  const storeRoot = isWs ? workspaceStorePath(row.workspace_key) : projectStorePath(row.project_key);
+  const runDir = await runDirForRow(row);
+  const sizeOf = (rel) => {
+    for (const base of [runDir, storeRoot]) {
+      try { return statSync(join(base, rel)).size; } catch { /* try next base */ }
+    }
+    return 0;
+  };
+  return raw.map((r) => ({
+    kind: r.kind,
+    stepKey: r.step_key ?? null,
+    nodeId: r.node_id ?? null,
+    cycle: r.cycle ?? null,
+    relPath: r.rel_path,
+    bytes: sizeOf(r.rel_path),
+    createdAt: r.created_at ?? null,
+  }));
+}
+
 /**
  * Upsert the clarify row for a pipeline. Pass { questions } and/or { answers }. A
  * partial call updates only the provided column, preserving the other. JSON-encoded
@@ -538,6 +597,32 @@ export function updatePhaseStatus(pipelineId, ordinal, status, ts) {
   } catch { /* best-effort */ }
 }
 
+/**
+ * Aggregate live run progress from the existing readers. Free-text fields
+ * (titles, review summaries, question/answer text) are redacted by the caller,
+ * not here — this is a pure data assembler. Returns null for an unknown run.
+ * @param {string} pipelineId
+ * @returns {Promise<null | {runId:string, phase:string|null, status:string|null, phases:Array, tasks:Array, clarify:object, reviews:Array, stepQuestions:Array}>}
+ */
+export async function readRunProgress(pipelineId) {
+  const row = findPipelineRowById(pipelineId);
+  if (!row) return null;
+  // Read against the RESOLVED id — `pipelineId` may be a run-dir basename/suffix
+  // (findPipelineRowById's DIR_ID_RE) that no downstream table keys on.
+  const id = row.id;
+  const extras = readPipelineExtras(id);
+  return {
+    runId: row.id,
+    phase: row.phase ?? null,
+    status: row.status ?? null,
+    phases: listPhases(id),
+    tasks: listTasks(id),
+    clarify: extras.clarify,
+    reviews: extras.reviews,
+    stepQuestions: extras.stepQuestions,
+  };
+}
+
 /**
  * Convert an arbitrary string to a safe kebab-case slug.
  * - Lowercases, replaces non-alphanumerics with hyphens, collapses repeats,
@@ -1138,6 +1223,22 @@ export function persistPrState(pipelineId, pr) {
   } catch { /* best-effort */ }
 }
 
+/**
+ * Last persisted PR facts for a pipeline (spec §6.8), or null when none were
+ * ever observed. Read by the later PR lookups so a cross-repo PR (which lives in
+ * the base repo, not the cwd's default) is resolved by URL instead of by branch.
+ * The resolved `state` (rowToState) deliberately omits pr_* — use this instead.
+ * @param {string} pipelineId
+ * @returns {{ url:string, number:(number|null), state:string }|null}
+ */
+export function readPrState(pipelineId) {
+  if (!pipelineId) return null;
+  try {
+    const row = getDb().prepare('SELECT pr_url, pr_number, pr_state FROM pipelines WHERE id = ?').get(pipelineId);
+    return row && row.pr_url ? { url: row.pr_url, number: row.pr_number ?? null, state: row.pr_state ?? 'OPEN' } : null;
+  } catch { return null; }
+}
+
 /**
  * The status a stale (crashed/killed) run is reconciled to. Distinct from a user
  * 'stopped' and a real 'error': the owning process died before Orchestrator.run()'s
@@ -1532,7 +1633,10 @@ async function rowToHistoryEntry(row, repoDir = null, opts = {}) {
   // unavailable we still set pr:null (the field is present whenever requested), so
   // callers can distinguish "looked, none" from "did not look".
   if (opts.withPr && repoDir && feature) {
-    entry.pr = (await hasGh()) ? await findPrForBranch({ projectDir: repoDir, head: feature }) : null;
+    // pr_url first (repo-agnostic view); the branch search only for rows with no PR yet.
+    entry.pr = (await hasGh())
+      ? await findPrForBranch({ projectDir: repoDir, head: feature, prUrl: row.pr_url || null })
+      : null;
   }
   return entry;
 }
@@ -1574,7 +1678,7 @@ export async function listPipelines(projectDir, opts = {}, workspaceKey) {
   const dirById = await runDirIndex(pipelinesDir);
   const rows = getDb().prepare(`
     SELECT id, project_key, target, title, status, started_at, updated_at, total_cost_usd, total_active_ms,
-           branch, workspace_meta, guardrails_id,
+           branch, workspace_meta, guardrails_id, pr_url,
            json_extract(CASE WHEN json_valid(resume_point) THEN resume_point END, '$.pauseReason') AS pause_reason,
            json_extract(CASE WHEN json_valid(resume_point) THEN resume_point END, '$.pauseDetail') AS pause_detail
     FROM pipelines
@@ -1603,7 +1707,7 @@ export async function listPipelines(projectDir, opts = {}, workspaceKey) {
 export async function listAllPipelines(opts = {}, { batchSize = 16 } = {}) {
   const rows = getDb().prepare(`
     SELECT id, project_key, workspace_key, target, title, status, started_at, updated_at,
-           total_cost_usd, total_active_ms, branch, workspace_meta, guardrails_id,
+           total_cost_usd, total_active_ms, branch, workspace_meta, guardrails_id, pr_url,
            json_extract(CASE WHEN json_valid(resume_point) THEN resume_point END, '$.pauseReason') AS pause_reason,
            json_extract(CASE WHEN json_valid(resume_point) THEN resume_point END, '$.pauseDetail') AS pause_detail
     FROM pipelines
@@ -1700,7 +1804,8 @@ export async function enrichPipelinesPr(onBatch, { batchSize = 16 } = {}) {
   for (let i = 0; i < targets.length; i += batchSize) {
     const slice = targets.slice(i, i + batchSize);
     const items = await Promise.all(slice.map(async (r) => {
-      const pr = (await findPrForBranch({ projectDir: r.projectDir, head: r.branch })) || null;
+      const prUrl = readPrState(r.id)?.url || null;
+      const pr = (await findPrForBranch({ projectDir: r.projectDir, head: r.branch, prUrl })) || null;
       if (pr) persistPrState(r.id, pr);   // positive observations only (null never clears)
       return { projectKey: r.projectKey, id: r.id, pr };
     }));
@@ -1889,6 +1994,13 @@ export function findPipelineRowById(id) {
   return row || null;
 }
 
+/** The detail `state` of ONE pipeline by id alone — any store key, archived included (the Ask Worca progress
+ *  card's hydration read). The keyed History routes keep their full payload; this is the bare rowToState. */
+export function readPipelineStateById(id) {
+  const row = findPipelineRowById(id);
+  return row ? rowToState(row) : null;
+}
+
 /**
  * The DB-backed lookups `sweepRunRoots` (worktree.mjs) needs, in ONE place shared by
  * both callers — `ui/server.mjs`'s boot sweep and the `worca doctor` subcommand.
@@ -2048,10 +2160,22 @@ export async function readPipelineByKey(key, id) {
     artifacts: await listArtifacts(row.id), // [{kind, relPath}] — drives the Live-logs dropdown (project + workspace)
     results,
     overview,
+    teamMetrics: readRunLedger(row.id),
+    memory: await readMemoryLedger(dir),
     ...readPipelineExtras(row.id),
   };
 }
 
+/** A run's memory ledger (<runDir>/memory.json, agent-memory P1 amendment A2) as
+ *  { mount, changes, totals }, or null when the run wrote none. The ONE reader: the History
+ *  detail above serves it whole, ask/tool-deps.mjs' readRunMemory serves get_run the
+ *  changes + totals (never the mount path). Read-only, null on any failure. */
+export async function readMemoryLedger(dir) {
+  const ledger = await readJsonFile(join(dir, 'memory.json'));
+  if (!ledger || !Array.isArray(ledger.changes)) return null;
+  return { mount: ledger.mount || null, changes: ledger.changes, totals: memoryTotals(ledger.changes) };
+}
+
 /** Local helper: read + JSON-parse a file, null on any failure. */
 async function readJsonFile(p) {
   try { return JSON.parse(await readFile(p, 'utf8')); } catch { return null; }

package/src/core/ask/catalog.mjs

@@ -6,7 +6,7 @@
 // Readers are injected so unit tests run without a DB.
 import { listProjects as realListProjects } from '../projects.mjs';
 import { listWorkspaces as realListWorkspaces } from '../workspaces.mjs';
-import { listWorkflows as realListWorkflows, GRAPH_DEFAULT_WORKFLOW } from '../workflows.mjs';
+import { listWorkflows as realListWorkflows, GRAPH_DEFAULT_WORKFLOW, GRAPH_MEMORY_DEFRAG_WORKFLOW } from '../workflows.mjs';
 import { classifyLoops } from '../../shared/graph/loops.mjs';
 import { rankNodes } from '../../shared/graph/layout.mjs';
 import { registryPortsFn } from '../graph/registry-ports.mjs';
@@ -27,6 +27,27 @@ function graphSteps(tpl, portsFn) {
   return [...byRank.keys()].sort((a, b) => a - b).map((r) => byRank.get(r));
 }
 import { loadAgentRegistry as realLoadAgentRegistry } from '../agent-registry.mjs';
+import { agentVocabulary } from '../auto/classify.mjs';
+
+/** The agents a hand-authored shape may place (spec §8.5): the classifier's vocabulary, one compact record each.
+ *  selfLoop mirrors the assembler's BAD_SELF_LOOP rule EXACTLY (assemble.mjs:349,:363-367): the agent's FIRST
+ *  `when:'blocking'` output exists and one of its `loop` inputs accepts that type (equal, or the input is `any`).
+ *  Read from the registry's port objects, not the card's summary strings. */
+export function shapeAgents(registry) {
+  const loops = (m) => {
+    const outs = Array.isArray(m?.outputs) ? m.outputs : [];
+    const blocking = outs.find((o) => o && o.when === 'blocking') || null;
+    if (!blocking) return false;
+    const ins = Array.isArray(m?.inputs) ? m.inputs.filter((p) => p && p.loop) : [];
+    return ins.some((i) => i.type === 'any' || i.type === blocking.type);
+  };
+  return agentVocabulary(registry, { domain: 'coding' })
+    .map((c) => ({
+      key: c.key, displayName: c.displayName, purpose: c.purpose, inputs: c.inputs, outputs: c.outputs,
+      verifier: c.verifier, clarifier: c.clarifier, selfLoop: loops(registry[c.key]), fanOut: c.fanOut, asksQuestions: c.asksQuestions,
+    }))
+    .sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+}
 
 /**
  * Pure: a stored workflow template → the catalog shape. `tpl.steps` is already
@@ -78,30 +99,34 @@ export function shapeWorkflow(tpl, registry = {}) {
 }
 
 /**
- * @param {{listProjects?:Function, listWorkspaces?:Function, listWorkflows?:Function, defaultWorkflow?:object, loadAgentRegistry?:Function}} [deps]
+ * @param {{listProjects?:Function, listWorkspaces?:Function, listWorkflows?:Function, defaultWorkflow?:object, builtinWorkflows?:object[], loadAgentRegistry?:Function}} [deps]
  */
 export function createCatalog({
   listProjects = realListProjects,
   listWorkspaces = realListWorkspaces,
   listWorkflows = realListWorkflows,
   defaultWorkflow = GRAPH_DEFAULT_WORKFLOW,
+  builtinWorkflows = [GRAPH_MEMORY_DEFRAG_WORKFLOW],
   loadAgentRegistry = realLoadAgentRegistry,
 } = {}) {
   async function buildCatalog() {
     const [projects, workspaces, workflows] = await Promise.all([listProjects(), listWorkspaces(), listWorkflows()]);
     let registry = {};
     try { registry = loadAgentRegistry() || {}; } catch { registry = {}; }
-    // Same order as GET /api/workflows: the graph default, then saved rows.
-    // shapeWorkflow already derives `steps` (condensation-topo ranks) +
-    // `feedbacks` (loop wires) for a v2 template, so the LLM-facing shape is unchanged.
+    // Same order as GET /api/workflows: the graph default, the other built-ins (Memory
+    // defragment — spec §7.2 wants the assistant to see it), then saved rows. wf_auto
+    // stays out: it has no graph. shapeWorkflow already derives `steps` + `feedbacks`.
+    const builtins = [defaultWorkflow, ...builtinWorkflows];
+    const builtinIds = new Set(builtins.map((t) => t.id));
     const templates = [
-      defaultWorkflow,
-      ...workflows.filter((t) => t && t.id !== defaultWorkflow.id),
+      ...builtins,
+      ...workflows.filter((t) => t && !builtinIds.has(t.id)),
     ];
     return {
       projects: projects.map((p) => ({ key: p.key, name: p.name, path: p.path })),
       workspaces: workspaces.map((w) => ({ id: w.id, name: w.name, projectKeys: [...(w.projectKeys || [])] })),
       workflows: templates.map((t) => shapeWorkflow(t, registry)),
+      agents: shapeAgents(registry),
     };
   }
   return { buildCatalog };

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

@@ -12,7 +12,7 @@
 // imports at all); tools.mjs owns the protected-path filter and the redaction, so
 // the fail-closed read rules live next to get_run_diff's.
 import {
-  addDiffComment, listDiffComments, getDiffComment, setDiffCommentResolved, deleteDiffComment,
+  addDiffComment, addDiffCommentReply, listDiffComments, getDiffComment, setDiffCommentResolved, deleteDiffComment,
 } from '../diff-comments.mjs';
 import { hunkContext } from '../diff-anchor.mjs';
 
@@ -40,13 +40,16 @@ export function defaultCommentDeps() {
       list: (storeKey, pipelineId, { status = 'all', path = null, patchText = null, keep = null } = {}) => {
         const rows = listDiffComments(storeKey, pipelineId, { status, path });
         const kept = typeof keep === 'function' ? rows.filter(keep) : rows;
-        return kept.map((c) => (patchText == null ? c : {
+        // Context for ROOTS only: a reply shares its root's anchor, and parsing the
+        // whole patch once more per reply would buy the model nothing (D7).
+        return kept.map((c) => ((patchText == null || c.parentId) ? c : {
           ...c,
           context: hunkContext(patchText, { project: c.projectKey, path: c.path, side: c.side, line: c.line },
             COMMENT_CONTEXT_RADIUS),
         }));
       },
       add: (input) => addDiffComment({ ...input, author: 'ask' }),
+      reply: (input) => addDiffCommentReply({ ...input, author: 'ask' }),
       get: (id) => getDiffComment(id),
       setResolved: (id, resolved) => setDiffCommentResolved(id, resolved),
       remove: (id) => deleteDiffComment(id),

package/src/core/ask/events.mjs

@@ -32,11 +32,12 @@ const weight = (u) => u.input + 1.25 * u.cacheCreation + 0.1 * u.cacheRead + 5 *
 const clone = (v) => JSON.parse(JSON.stringify(v));
 const short = (name) => String(name ?? '').replace(/^mcp__worca__/, '');
 const isAgentTool = (name) => name === 'Task' || name === 'Agent';
-// The three write tools whose success must reach the browser. The reducer runs in
+// The four write tools whose success must reach the browser. The reducer runs in
 // the PARENT process, so this is the only place a child-process write becomes a
 // broadcast (the MCP server cannot call broadcast()).
 const COMMENT_WRITE_TOOLS = new Set([
-  'mcp__worca__add_diff_comment', 'mcp__worca__resolve_diff_comment', 'mcp__worca__delete_diff_comment',
+  'mcp__worca__add_diff_comment', 'mcp__worca__reply_to_diff_comment',
+  'mcp__worca__resolve_diff_comment', 'mcp__worca__delete_diff_comment',
 ]);
 // The worktree-mutating tools (P4): the MCP child opens/removes checkouts and
 // moves HEAD (checkout/switch/fetch → tools.mjs noteNav) — invisible to this
@@ -45,6 +46,10 @@ const COMMENT_WRITE_TOOLS = new Set([
 // only when its subcommand is one noteNav acts on; a `log`/`status` never pokes.
 const WORKTREE_TOOLS = new Set(['mcp__worca__open_worktree', 'mcp__worca__remove_worktree', 'mcp__worca__git']);
 const GIT_NAV_SUBCOMMANDS = new Set(['checkout', 'switch', 'fetch']);
+// The memory writers (agent-memory-design.md §9.1): a successful remember/forget in the CHILD
+// becomes the same `memory-changed` broadcast the REST routes emit (ui/server.mjs emitMemoryChanged).
+// The scope key rides the tool RESULT (`scopeKey`), like pokeCommentWrite reads `comment.runId`.
+const MEMORY_WRITE_TOOLS = new Set(['mcp__worca__remember', 'mcp__worca__forget']);
 /** True when a SUCCESSFUL call of `name` with `input` changed this thread's worktree rows. */
 export function worktreeMutatingCall(name, input) {
   if (!WORKTREE_TOOLS.has(name)) return false;
@@ -118,11 +123,22 @@ export function labelForTool(name, input = {}, attachmentNames = {}) {
     case 'list_workflows': return 'Looking at workflows';
     case 'list_projects': return 'Looking at projects';
     case 'propose_run': return 'Preparing a run';
+    case 'propose_workflow': return 'Building a workflow';
+    case 'propose_metrics_change': return 'Proposing a metrics change';
+    case 'get_team_metrics': return 'Reading team metrics';
+    case 'list_team_metrics_runs': return 'Listing team runs';
+    case 'push_team_metrics': return 'Pushing team metrics';
+    case 'track_run': return 'Tracking a run';
     case 'read_attachment': return `Reading ${(attachmentNames && attachmentNames[id]) || 'attachment'}`;
     case 'list_diff_comments': return id ? `Reading comments on ${id.slice(0, 12)}` : 'Reading diff comments';
     case 'add_diff_comment': return 'Writing a diff comment';
+    case 'reply_to_diff_comment': return 'Replying to a diff comment';
     case 'resolve_diff_comment': return 'Updating a diff comment';
     case 'delete_diff_comment': return 'Deleting a diff comment';
+    case 'list_memory': return 'Reading memory';
+    case 'read_memory': return input?.name ? `Reading memory: ${input.name}` : 'Reading memory';
+    case 'remember': return input?.name ? `Saving memory: ${input.name}` : 'Saving memory';
+    case 'forget': return input?.name ? `Removing memory: ${input.name}` : 'Removing memory';
     default: return `Using ${n}`;
   }
 }
@@ -159,8 +175,13 @@ export function createTurnReducer({
   setTimeout: setT = globalThis.setTimeout,
   clearTimeout: clearT = globalThis.clearTimeout,
   onProposal = null,
+  onWorkflowStart = null,
+  onWorkflowResult = null,
+  onMetricsProposal = null,      // propose_metrics_change RESULT (team metrics card; the parent re-validates the input)
+  onTrackRun = null,
   onCommentMutation = null,
   onWorktreeMutation = null,
+  onMemoryMutation = null,
   estimateLiveCost = null,
   attachmentNames = {},
   resolveCost = null,
@@ -348,6 +369,11 @@ export function createTurnReducer({
           fullInputs.set(c.id, input);
           label(labelForTool(c.name, input, attachmentNames));
           upsertBlock({ kind: 'tool', id: c.id, name: c.name, input: clipJson(input, limits.blockIoMaxChars), status: 'running', durationMs: null });
+          // P3: the workflow card exists from the tool_use on (state 'building' — the four-step trace), so the
+          // START is a hook too. Sync: the block must precede any frame the tool result produces.
+          if (c.name === 'mcp__worca__propose_workflow' && typeof onWorkflowStart === 'function') {
+            try { onWorkflowStart({ toolUseId: c.id, input }); } catch { reducerErrors += 1; }
+          }
         }
       } else {
         const agent = byId.get(ptu);
@@ -387,6 +413,18 @@ export function createTurnReducer({
     try { onWorktreeMutation({ tool: short(name) }); } catch { /* a broken sink never breaks the stream */ }
   }
 
+  // And for memory: a remember/forget succeeded in the CHILD, so the parent broadcasts the same
+  // `memory-changed` frame the REST writes emit. Note the asymmetry with the worktree poke — that
+  // one reads the call INPUT, this one the result TEXT, because the scope key rides the result.
+  function pokeMemoryWrite(name, text, isError) {
+    if (isError || !MEMORY_WRITE_TOOLS.has(name) || typeof onMemoryMutation !== 'function') return;
+    try {
+      const parsed = JSON.parse(text);
+      const scope = typeof parsed?.scopeKey === 'string' ? parsed.scopeKey : null;
+      if (scope) onMemoryMutation({ scope, tool: short(name) });
+    } catch { /* unparseable result — no poke; the next open refetches anyway */ }
+  }
+
   function onUser(raw, ptu, isMain) {
     const content = Array.isArray(raw.message?.content) ? raw.message.content : [];
     for (const c of content) {
@@ -400,6 +438,7 @@ export function createTurnReducer({
         if (agent) appendLog(agent, c.is_error ? `← error: ${clipStr(text, 120)}` : `← ok ${((now() - ct.t0) / 1000).toFixed(1)}s`);
         pokeCommentWrite(ct.name, text, c.is_error);
         pokeWorktreeMutation(ct.name, ct.input, c.is_error);
+        pokeMemoryWrite(ct.name, text, c.is_error);
         continue;
       }
       const b = byId.get(c.tool_use_id);
@@ -435,8 +474,32 @@ export function createTurnReducer({
           if (ret && typeof ret.then === 'function') pendingHooks.push(ret.then(() => {}, () => { reducerErrors += 1; }));
         } catch { reducerErrors += 1; }
       }
+      if (b.name === 'mcp__worca__propose_workflow' && typeof onWorkflowResult === 'function') {
+        // The RAW result text: the parent re-validates from the returned shape (spec §8.2, PD1); an isError result
+        // carries "error: <message>" and flips the card to failed.
+        try {
+          const ret = onWorkflowResult({ toolUseId: b.id, input: fullInputs.get(b.id) ?? {}, text, isError: !!c.is_error });
+          if (ret && typeof ret.then === 'function') pendingHooks.push(ret.then(() => {}, () => { reducerErrors += 1; }));
+        } catch { reducerErrors += 1; }
+      }
+      if (b.name === 'mcp__worca__propose_metrics_change' && typeof onMetricsProposal === 'function') {
+        // The parent re-validates from the tool INPUT (metrics-proposal.mjs is pure over the real readers);
+        // the raw result text only says whether the child accepted it.
+        try {
+          const ret = onMetricsProposal({ toolUseId: b.id, input: fullInputs.get(b.id) ?? {}, text, isError: !!c.is_error });
+          if (ret && typeof ret.then === 'function') pendingHooks.push(ret.then(() => {}, () => { reducerErrors += 1; }));
+        } catch { reducerErrors += 1; }
+      }
+      if (b.name === 'mcp__worca__track_run' && typeof onTrackRun === 'function') {
+        // The parent owns the runs Map, the link rows and the followers: it re-resolves the id itself (D4).
+        try {
+          const ret = onTrackRun({ toolUseId: b.id, input: fullInputs.get(b.id) ?? {}, text, isError: !!c.is_error });
+          if (ret && typeof ret.then === 'function') pendingHooks.push(ret.then(() => {}, () => { reducerErrors += 1; }));
+        } catch { reducerErrors += 1; }
+      }
       pokeCommentWrite(b.name, text, c.is_error);
       pokeWorktreeMutation(b.name, fullInputs.get(b.id), c.is_error);
+      pokeMemoryWrite(b.name, text, c.is_error);
     }
   }
 

package/src/core/ask/limits.mjs

@@ -35,7 +35,16 @@ export const ASK_LIMITS = Object.freeze({
   worktreesGlobal: 15,                     // P4 D9
   attachmentReadDefaultBytes: 32_000,
   attachmentReadMaxBytes: 200_000,
+  artifactsListMaxLimit: 200,
+  artifactReadDefaultBytes: 60_000,
+  artifactReadMaxBytes: 200_000,
   briefMaxChars: 8000,
+  metricsRunsDefaultLimit: 20,             // list_team_metrics_runs page (= listRunsDefaultLimit)
+  metricsRunsMaxLimit: 100,                // list_team_metrics_runs page cap (= listRunsMaxLimit)
+  metricsBreakdownMaxRows: 20,             // get_team_metrics rows per breakdown dimension
+  workflowTaskMaxChars: 32_000,            // propose_workflow task text (= classify.mjs TASK_TEXT_CAP)
+  workflowNoteMaxChars: 200,               // propose_workflow note shown on the card
+  proposalNoteMaxChars: 200,               // propose_run note ("why this shape") shown on the run card
   commentBodyMaxChars: 4000,               // diff_comments.body cap (pinned equal to COMMENT_BODY_MAX)
   titleMaxChars: 120,
   headerRuns: 5,

package/src/core/ask/mcp-stdio.mjs

@@ -24,7 +24,10 @@ import { pathToFileURL } from 'node:url';
 import { createAskTools, AskToolError } from './tools.mjs';
 import { defaultToolDeps } from './tool-deps.mjs';
 import { defaultWorktreeDeps } from './worktree-deps.mjs';
+import { defaultMemoryDeps } from './memory-deps.mjs';
 import { defaultCommentDeps } from './comment-deps.mjs';
+import { defaultWorkflowDeps } from './workflow-deps.mjs';
+import { defaultMetricsDeps } from './metrics-deps.mjs';
 
 const SUPPORTED_PROTOCOLS = Object.freeze(['2024-11-05', '2025-03-26', '2025-06-18', '2025-11-25']);
 const DEFAULT_PROTOCOL = '2025-06-18';
@@ -112,17 +115,24 @@ export async function main({ argv = process.argv.slice(2), env = process.env, st
   const { home, thread } = parseArgv(argv);
   if (home) env.WORCA_HOME = home;                               // argv wins; worcaHome() reads the env at call time
   const threadId = thread || env.WORCA_ASK_THREAD_ID || null;
+  // P3 (v7): stdin closing == the chat turn ended or was stopped — abort whatever propose_workflow is still classifying
+  // (its result could never be delivered), so the drain below returns promptly instead of after the classifier's timeout.
+  const life = new AbortController();
   const server = createRpcServer({
     tools: createAskTools({
       ...defaultToolDeps({ threadId }),
       ...defaultWorktreeDeps({ threadId }),
+      ...defaultMemoryDeps({ threadId }),
       ...defaultCommentDeps(),
+      ...defaultWorkflowDeps({ threadId, signal: life.signal }),
+      ...defaultMetricsDeps({ threadId }),
     }),
     write: (s) => stdout.write(s),
   });
   const rl = createInterface({ input: stdin });
   rl.on('line', (line) => { server.feed(line); });
   await new Promise((resolve) => rl.on('close', resolve));
+  life.abort();
   await server.idle();
   await new Promise((resolve) => stdout.write('', resolve));      // macOS pipes are async: drain before exit
 }

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

@@ -0,0 +1,107 @@
+// src/core/ask/memory-deps.mjs
+// The dep bundle of the memory tools (agent-memory-design.md §9.1; P2 amendment B3) — reads AND
+// writes under ONE namespaced sub-object, exactly like worktree-deps.mjs / comment-deps.mjs.
+// Deliberately separate from tool-deps.mjs, whose source is pinned read-only. Everything goes
+// through src/core/memory-store.mjs (validation, frontmatter repair, caps, snapshots, counters),
+// so the MCP path and the REST path share one writer. Also the chat's --add-dir memory mount.
+import { join } from 'node:path';
+import {
+  memoryRoot, listMemory, readMemory, writeMemory, removeMemory, renderMemoryFile, MEMORY_NAME_HELP,
+} from '../memory-store.mjs';
+import { mountDirs, withStoreLock, refreshMount } from '../memory-sync.mjs';
+import { memoryCaps } from '../settings.mjs';
+import { listProjects, worcaHome } from '../projects.mjs';
+import { PROJECT_KEY_RE } from '../store.mjs';
+import { getThread } from './store.mjs';
+
+/** {key, name, path} for a registered project key, or null. */
+async function projectByKey(key) {
+  if (typeof key !== 'string' || !key) return null;
+  const p = (await listProjects()).find((x) => x && x.key === key);
+  return p ? { key: p.key, name: p.name || '', path: p.path } : null;
+}
+
+export function defaultMemoryDeps({ threadId }) {
+  const source = `ask:${threadId || 'unknown'}`;
+  return {
+    memory: {
+      projectByKey,
+      /** The page-following (unpinned) project of this thread, or null — tool-deps' pinnedScope
+       *  covers the pinned case. B30: the context the panel sends carries `projectDir` on the New,
+       *  Running and Projects pages and `projectKey` only on History detail, so this mirrors
+       *  resolveAskContext (ui/server.mjs) and resolves either through the registry. */
+      contextProjectKey: async () => {
+        if (!threadId) return null;
+        let c = null;
+        try { c = getThread(threadId)?.context ?? null; } catch { return null; }
+        if (!c || c.pinned === true) return null;
+        if (typeof c.projectKey === 'string' && c.projectKey) return c.projectKey;
+        if (typeof c.projectDir === 'string' && c.projectDir) {
+          try {
+            const p = (await listProjects()).find((x) => x && x.path === c.projectDir);   // the match resolveAskContext uses
+            return p ? p.key : null;
+          } catch { return null; }
+        }
+        return null;
+      },
+      list: (scope) => listMemory(memoryRoot(), scope),
+      read: (scope, name) => readMemory(memoryRoot(), scope, name),
+      /** Compose + write one file. Omitted description/paths keep the existing file's values (an
+       *  omission never erases); `append` joins the bodies with one blank line (replace on a new
+       *  file). Read-compose-write under the store lock (I2-#13) so two turns of THIS process
+       *  cannot lose an append; a concurrent MCP child or a run's sync-back is not covered — that
+       *  race is a Non-goal, and the pre-write snapshot keeps the losing version. */
+      remember: (scope, { name, body, description, paths, mode = 'replace' }) => withStoreLock(memoryRoot(), async () => {
+        const existing = await readMemory(memoryRoot(), scope, name);
+        const meta = {
+          name,
+          description: description == null ? (existing?.meta.description || '') : String(description),
+          paths: paths == null ? (existing?.meta.paths || []) : paths,
+          extra: existing?.meta.extra || {},
+        };
+        const nextBody = mode === 'append' && existing ? `${existing.body.trimEnd()}\n\n${String(body).trim()}\n` : String(body);
+        const r = await writeMemory(memoryRoot(), scope, name, renderMemoryFile(meta, nextBody), { source, caps: memoryCaps() });
+        return { created: r.created, bytes: r.bytes };
+      }),
+      forget: (scope, name) => removeMemory(memoryRoot(), scope, name, { source }),
+    },
+  };
+}
+
+/** `<home>/ask/memory/<projectKey|global>` — the --add-dir base of one scope set. Never the cwd (one
+ *  Claude Code project slug for every thread) and never under tmp/ (Read-denied there). `global` is a
+ *  safe sentinel: a registry key is `<slug>-<8 hex>` (PROJECT_KEY_RE), so it can never be that word. */
+export function askMemoryMountBase(projectKey) { return join(worcaHome(), 'ask', 'memory', projectKey || 'global'); }
+
+/**
+ * Refresh the chat's rules mount for one scope set (native-rules revision, D16): global + the
+ * given project, written under `<base>/.claude/rules/worca/{global,project}/` — the layout the
+ * CLI loads through `--add-dir <base>` + CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1 (probes J/J2).
+ * The writing is memory-sync's refreshMount (NON-destructive: files written atomically by name,
+ * stale ones unlinked, dirs never removed — a turn already spawning on the same mount must not
+ * read an empty dir; a file that cannot be written keeps its previous copy and is reported).
+ * Serialised under the store lock so it never interleaves with an in-process sync or remember
+ * (the MCP child writes from another process; whole-file atomic writes make that harmless).
+ * `async` on purpose: the projectKey guard REJECTS rather than throwing at the call site.
+ * @returns {Promise<string|null>} the base to pass as --add-dir, or null when the scope set holds
+ *   no file (B33: nothing to load ⇒ the spawn stays byte-identical); the mount is emptied then.
+ */
+export async function refreshAskMemoryMount({ projectKey = null, projectName = null } = {}) {
+  // A path segment: refuse anything but a registry-shaped key before a single mkdir (defence in
+  // depth — today's only caller passes a resolved key; the shape store.mjs#projectKey produces and
+  // the server's memory routes test). The rejection lands in the turn's catch.
+  if (projectKey != null && !PROJECT_KEY_RE.test(projectKey)) throw new Error(`refreshAskMemoryMount: invalid projectKey ${JSON.stringify(projectKey)}`);
+  const base = askMemoryMountBase(projectKey);
+  const dirs = mountDirs({ members: projectKey ? [{ projectKey, projectName }] : [], isWorkspace: false });
+  return withStoreLock(memoryRoot(), async () => {
+    // Two different failures reach ONE callback: a junk name / unreadable file in the STORE (the
+    // listing, `listMemoryDir` → ENAME) and a mount target that could not be written (the rename).
+    // Only the second has a "previous copy"; reporting a store name that way would promise a copy
+    // that never existed and name a path the user cannot fix by retrying.
+    const onError = (p, err) => console.warn(err?.code === 'ENAME'
+      ? `[worca-ask] memory: ignoring ${JSON.stringify(p)} — ${MEMORY_NAME_HELP}`
+      : `[worca-ask] memory mount: ${p} could not be refreshed (${err?.message || err}); the previous copy (if any) is served this turn`);
+    const { files } = await refreshMount({ root: memoryRoot(), mount: join(base, '.claude', 'rules', 'worca'), dirs, onError });
+    return files ? base : null;
+  });
+}