@dotdrelle/wiki-manager 0.14.13 → 0.14.20

package/src/cli/wiki-manager.js

@@ -8,6 +8,7 @@ import { createAgentGraph } from '../agent/graph.js';
 import { handleSlashCommand, printHelp, printVersion, refreshMcpRuntimeStatus } from '../commands/slash.js';
 import { runShell, runHeadlessChatTurn } from '../shell/repl.js';
 import { runPreflightChecks, withRuntimePreflight } from '../core/startupCheck.js';
+import { refreshRunningContainers } from '../core/wikiSetup.js';
 import { applySessionWikircProfile } from '../core/sessionConfig.js';
 import { listWikircProfiles } from '../core/wikirc.js';
 import { callMcpTool, formatMcpToolResult, readChatAccessConfig } from '../core/mcp.js';
@@ -17,6 +18,7 @@ import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core
 import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
 import { resolveCapabilityConcurrency } from '../orchestrator/scheduler.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
+import { listWorkspaces } from '../core/workspaces.js';
 // Runtime modules use node:sqlite (Node.js built-in unavailable in Bun).
 // They are imported dynamically so the shell / TUI path never loads them.
 
@@ -112,6 +114,18 @@ export async function forwardRuntimeApproval(getWorkspaceContext, request = {})
   return context.approvalManager?.approve(request) ?? { approved: false };
 }
 
+export function resolvePreparedDelegationApproval({
+  autoApprove = false,
+  approvalManager = null,
+  runId,
+} = {}) {
+  if (autoApprove !== true || typeof approvalManager?.approve !== 'function') {
+    return { approved: false, awaitingApproval: true };
+  }
+  const result = approvalManager.approve({ scope: 'run', runId });
+  return { approved: true, awaitingApproval: false, result };
+}
+
 function timestampForFile() {
   return new Date().toISOString().replace(/[:.]/g, '-');
 }
@@ -422,7 +436,7 @@ async function runHeadless(argv, agent) {
     let input = prompt;
     if (skillName) {
       const skillResult = await handleSlashCommand(`/skills run ${skillName}`, { packageJson, session, onStep: step });
-      if (skillResult.output) log.push(skillResult.output);
+      if (skillResult.output && !skillResult.rawOutput) log.push(skillResult.output);
       if (String(skillResult.output ?? '').startsWith('Skill not found')) throw new Error(`Skill not found: ${skillName}`);
       input = skillResult.agentTrigger
         ? [
@@ -501,7 +515,7 @@ async function runRuntime(argv, agent) {
   const { defaultRuntimeStateDir, openRuntimeStore, RECOVERABLE_QUEUE_STATUSES } = await import('../runtime/store.js');
   const { startRuntimeServer } = await import('../runtime/server.js');
   const { recoverActiveRuns } = await import('../runtime/recoveryManager.js');
-  const { emitRuntimeLog, startActivitySupervisor, cancelActiveActivityJobs } = await import('../runtime/supervisor.js');
+  const { emitRuntimeLog, startActivitySupervisor, cancelActiveActivityJobs, discoverAgentsOnce } = await import('../runtime/supervisor.js');
   const { resolveRuntimeAuthToken } = await import('../runtime/auth.js');
   const { createSqliteQueueStore } = await import('../runtime/queueStore.js');
   const { createApprovalManager } = await import('../runtime/approvals.js');
@@ -803,6 +817,12 @@ async function runRuntime(argv, agent) {
     const { resolveObjective } = await import('../orchestrator/objectiveResolver.js');
     const { validateFragment } = await import('../orchestrator/planValidator.js');
     const session = context.session;
+    // The supervisor starts discovery asynchronously. A delegation submitted
+    // immediately after opening ShellUI must not observe the transient empty
+    // registry and fail while the provider is already healthy. Refresh the
+    // live endpoints and await one discovery pass before resolving.
+    await refreshMcpRuntimeStatus(session);
+    await discoverAgentsOnce(session, { registry: session.agentRegistry });
     let selection;
     try {
       selection = await resolveObjective(objective, session);
@@ -915,14 +935,24 @@ async function runRuntime(argv, agent) {
           throw new Error(`Delegated plan integration failed: ${(integrated.errors ?? []).map((error) => error.message ?? error.code ?? String(error)).join('; ')}`);
         }
         emitRuntimeLog(session, `delegation: ${prepared.fragment.tasks.length} validated task(s) integrated from ${prepared.provider.serverName}.agent_plan (${prepared.capability}/${prepared.operation})`);
-        // Demandé = consenti: a directly-delegated run carries the user's
-        // explicit consent, so auto-approve its initial plan. Persisting a
-        // run-scope grant (via the approval manager) makes the scheduler's
-        // readyTasks approval check pass, so the tasks run without re-prompting.
-        // Replanned tasks are integrated later without a fresh grant.
-        if (context.approvalManager?.approve) {
-          context.approvalManager.approve({ scope: 'run', runId });
-          emitRuntimeLog(session, `approval: run ${runId} auto-approved (user-requested action)`);
+        // Real approval gate (opt-out): a directly-delegated run only skips the
+        // human approval step when the caller explicitly opts in via
+        // `autoApprove` (e.g. headless/CI, or a future "trust this run" toggle).
+        // By default the run WAITS: integrate() above created the per-task
+        // approval requests, and the scheduler's approvalCovered() filter blocks
+        // the mutating tasks until a run-scope grant arrives (/approve or
+        // "valide tout"). This keeps a visible pending_approval window instead of
+        // resolving it programmatically ~30ms after launch, which no polled UI
+        // could ever render.
+        const approval = resolvePreparedDelegationApproval({
+          autoApprove: body.autoApprove,
+          approvalManager: context.approvalManager,
+          runId,
+        });
+        if (approval.approved) {
+          emitRuntimeLog(session, `approval: run ${runId} auto-approved (autoApprove opt-in)`);
+        } else {
+          emitRuntimeLog(session, `approval: run ${runId} awaiting explicit approval before mutations (/approve or « valide tout »)`);
         }
         body._planReady?.resolve?.({ runId, planRevision: session.agentProjection?.planRevision ?? 0 });
       }
@@ -1162,10 +1192,22 @@ async function runRuntime(argv, agent) {
   await new Promise(() => {});
 }
 
+// One place for the skipped-image-update warnings so the runtime and TUI
+// startup paths report refresh failures identically.
+function logImageRefreshErrors(imageRefresh) {
+  for (const error of imageRefresh?.errors ?? []) {
+    console.warn(`[wiki-manager] image update skipped: ${error}`);
+  }
+}
+
 export async function runCli(argv) {
   if (argv[0] === 'runtime') {
     const scaffolded = ensureManagerScaffold({ log: (message) => console.log(`[wiki-manager] ${message}`) });
     if (scaffolded.length > 0) loadManagerEnv();
+    const imageRefresh = await refreshRunningContainers({
+      onStep: (message) => console.log(`[wiki-manager] ${message}`),
+    });
+    logImageRefreshErrors(imageRefresh);
     const agent = createAgentGraph();
     await runRuntime(argv.slice(1), agent);
     return;
@@ -1218,6 +1260,10 @@ export async function runCli(argv) {
     if (!process.versions.bun) {
       throw new Error('Interactive TUI requires Bun. Run: bun ./bin/wiki-manager.js');
     }
+    const initialWorkspaceName = valueAfter(argv, '--workspace');
+    if (initialWorkspaceName && !listWorkspaces().some((workspace) => workspace.name === initialWorkspaceName)) {
+      throw new Error(`Workspace not found: ${initialWorkspaceName}`);
+    }
     const { runOpenTuiShell, runStartupWizard } = await import('../shell/tui.tsx');
     // Fresh directory → copy mcp.endpoints.json/.env from the packaged
     // examples so external agents (cme, mailer, documents) connect out of
@@ -1242,6 +1288,17 @@ export async function runCli(argv) {
       // configuration. Re-read everything before drawing the home screen.
       preflight = await runPreflightChecks();
     }
+    const dockerReady = preflight.checks.some((check) => check.kind === 'docker' && check.ok);
+    const internetReady = preflight.checks.some((check) => check.kind === 'internet' && check.ok);
+    if (dockerReady && internetReady) {
+      void refreshRunningContainers({
+        onStep: (message) => console.log(`[wiki-manager] ${message}`),
+      }).then((imageRefresh) => {
+        logImageRefreshErrors(imageRefresh);
+      }).catch((error) => {
+        console.warn(`[wiki-manager] image update skipped: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }
     let runtime = null;
     try {
       const { ensureRuntime } = await import('../runtime/lifecycle.js');
@@ -1257,7 +1314,13 @@ export async function runCli(argv) {
     // (see tui.tsx onShellExit): render() resolves at MOUNT, so anything
     // after this await would run while the shell is still on screen —
     // 0.12.9 shipped exactly that bug and killed the runtime under the user.
-    await runOpenTuiShell({ agent, packageJson, runtime, preflight });
+    await runOpenTuiShell({
+      agent,
+      packageJson,
+      runtime,
+      preflight,
+      initialWorkspaceName,
+    });
     return;
   }
 

package/src/cli/wiki-manager.test.js

@@ -1,6 +1,9 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { forwardRuntimeApproval } from './wiki-manager.js';
+import {
+  forwardRuntimeApproval,
+  resolvePreparedDelegationApproval,
+} from './wiki-manager.js';
 
 test('runtime approval bridge preserves the complete run-scoped grant', async () => {
   let forwarded = null;
@@ -26,3 +29,39 @@ test('runtime approval bridge preserves the complete run-scoped grant', async ()
   assert.deepEqual(forwarded, request);
   assert.deepEqual(result, { approved: true });
 });
+
+test('prepared delegation waits for explicit approval by default', () => {
+  let calls = 0;
+  const result = resolvePreparedDelegationApproval({
+    runId: 'run-gated',
+    approvalManager: {
+      approve() {
+        calls += 1;
+      },
+    },
+  });
+
+  assert.equal(calls, 0);
+  assert.deepEqual(result, { approved: false, awaitingApproval: true });
+});
+
+test('prepared delegation only approves when autoApprove is explicitly true', () => {
+  let forwarded = null;
+  const result = resolvePreparedDelegationApproval({
+    autoApprove: true,
+    runId: 'run-headless',
+    approvalManager: {
+      approve(request) {
+        forwarded = request;
+        return { approved: true };
+      },
+    },
+  });
+
+  assert.deepEqual(forwarded, { scope: 'run', runId: 'run-headless' });
+  assert.deepEqual(result, {
+    approved: true,
+    awaitingApproval: false,
+    result: { approved: true },
+  });
+});

package/src/commands/slash.js

@@ -391,7 +391,10 @@ function skillDetailText(skill) {
 
 function buildSkillRunPrompt(skill) {
   return [
-    `Execute the "${skill.name}" skill for the current workspace.`,
+    `The user asked to run the "${skill.name}" skill for the current workspace.`,
+    'First explain concisely, in the user language, what will be launched and its intended outcome.',
+    'Do not quote, reproduce, or display the raw skill content.',
+    'Then execute the workflow, using the available tools when required.',
     'Follow the workflow steps below. Call MCP tools and shell commands as needed for each step.',
     'Report progress as you go. Ask for confirmation before irreversible or costly actions not already defined in the skill.',
     '',
@@ -413,7 +416,11 @@ function skillActionCommand(session, action, name) {
     return { output: `Skill not found: ${name}.${hint}` };
   }
   if (action === 'run') {
-    return { output: `Skill: ${skill.name} — launching…`, agentTrigger: buildSkillRunPrompt(skill) };
+    return {
+      output: JSON.stringify({ operation: 'run-skill', skill: skill.name }),
+      rawOutput: true,
+      agentTrigger: buildSkillRunPrompt(skill),
+    };
   }
   return { output: skillDetailText(skill) };
 }
@@ -603,7 +610,7 @@ Options:
   --cacert <path>      Trust a local CA; Docker must be able to read this host path
   --once <prompt>      Run one agent turn and exit
   --headless           Run a workspace task non-interactively
-  --workspace <name>   Workspace for --headless
+  --workspace <name>   Initial workspace (interactive or --headless)
   --skill <name>       Skill to run in --headless (implies --wait)
   --prompt <text>      Task or extra instruction for --headless
   --log-file <path>    Optional headless log path

package/src/commands/slash.test.js

@@ -93,6 +93,30 @@ test('/new without a name shows usage', async () => {
   assert.match(result.output ?? '', /Usage/i);
 });
 
+test('/skills run sends the private skill body to Donna without rendering it as command output', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'wiki-manager-skill-run-'));
+  const skillDir = join(root, '.wiki', 'skills');
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(join(skillDir, 'pipeline.md'), [
+    '---',
+    'name: pipeline',
+    'description: Build the deliverables',
+    '---',
+    'SECRET WORKFLOW BODY',
+    '',
+  ].join('\n'), 'utf8');
+
+  const result = await handleSlashCommand('/skills run pipeline', {
+    packageJson: { version: 'test' },
+    session: { workspacePath: root },
+  });
+
+  assert.equal(result.rawOutput, true);
+  assert.doesNotMatch(result.output, /SECRET WORKFLOW BODY/);
+  assert.match(result.agentTrigger, /SECRET WORKFLOW BODY/);
+  assert.match(result.agentTrigger, /Do not quote, reproduce, or display the raw skill content/);
+});
+
 test('/use loads only workspaces and /config use switches wikirc profiles', async () => {
   const root = await mkdtemp(join(tmpdir(), 'wiki-manager-use-profile-'));
   const registryRoot = join(root, 'registry');

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.14.13",
-  "commit": "f0faf8b"
+  "version": "0.14.20",
+  "commit": "8833a7e"
 }

package/src/core/dockerCompose.test.js

@@ -11,6 +11,10 @@ test('workspace compose does not start a per-workspace agent runtime', async ()
   assert.equal(compose.services['agent-runtime'], undefined);
   assert.deepEqual(aliases.all.targets, ['serve', 'mcp-http', 'production-mcp']);
   assert.equal(aliases.runtime, undefined);
+  assert.equal(
+    compose.services.serve.environment.includes('WIKI_MANAGER_RUNTIME_URL=http://host.docker.internal:${WIKI_MANAGER_RUNTIME_PORT:-7788}'),
+    true,
+  );
 });
 
 test('agent compose services run as the host uid and gid', async () => {

package/src/core/env.test.js

@@ -29,6 +29,9 @@ test('scaffold copies the packaged examples into a fresh directory', () => {
     const endpoints = JSON.parse(readFileSync(join(dir, 'mcp.endpoints.json'), 'utf8'));
     assert.ok(endpoints.mcpServers);
     assert.ok(endpoints.chatAccess);
+    const env = readFileSync(join(dir, '.env'), 'utf8');
+    assert.match(env, /^# WIKI_MANAGER_RUNTIME_HOST=0\.0\.0\.0$/m);
+    assert.match(env, /^# WIKI_MANAGER_RUNTIME_PORT=7788$/m);
   });
 });
 

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.14.13';
+const WIKI_MANAGER_VERSION = '0.14.20';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/wikiSetup.js

@@ -105,6 +105,41 @@ export async function stopAgents(options = {}) {
   }
 }
 
+export async function refreshRunningContainers(options = {}) {
+  if (process.env.WIKI_MANAGER_AUTO_UPDATE === '0') {
+    return { skipped: true, refreshed: [] };
+  }
+  const script = join(managerRoot(), 'wiki-workspace');
+  const common = {
+    cwd: dirname(managerEnvFile()),
+    env: {
+      ...process.env,
+      WIKI_WORKSPACES_DIR: workspacesDir(),
+      WIKI_MANAGER_ENV_FILE: managerEnvFile(),
+      WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
+      AGENTS_DATA_DIR: resolveAgentsDataDir(),
+    },
+    timeout: options.timeout ?? 600_000,
+    maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
+  };
+  const targets = [['agents', 'refresh'], ...listWorkspaces().map((workspace) => ['wiki', workspace.name, 'refresh'])];
+  // Each target is an independent Compose project (its own agents/workspace
+  // stack) — refresh them concurrently instead of summing every target's
+  // pull/restart time into one sequential wait.
+  const results = await Promise.all(targets.map(async (args) => {
+    options.onStep?.(`Images: checking ${args[0] === 'agents' ? 'running agents' : `workspace ${args[1]}`}…`);
+    try {
+      const { stdout, stderr } = await execFileAsync(script, args, common);
+      return { ok: true, output: [stdout, stderr].filter(Boolean).join('\n').trim() };
+    } catch (err) {
+      return { ok: false, error: wrapDockerError(err).message };
+    }
+  }));
+  const refreshed = results.filter((result) => result.ok).map((result) => result.output).filter(Boolean);
+  const errors = results.filter((result) => !result.ok).map((result) => result.error);
+  return { skipped: false, refreshed, errors };
+}
+
 export async function createNewWorkspace(name, targetPath) {
   try {
     const output = await createWorkspace(name, targetPath, { timeout: 600_000 });

package/src/core/wikiWorkspace.test.js

@@ -31,3 +31,23 @@ test('wiki-workspace regenerates CA compose overrides instead of retaining remov
   assert.match(script, /mv "\$tmp_override" "\$override_path"/);
   assert.match(script, /Changes are overwritten on the next compose command/);
 });
+
+test('workspace creation keeps mutable manager files outside the installed package', async () => {
+  const source = await readFile(new URL('./workspaces.js', import.meta.url), 'utf8');
+
+  assert.match(source, /const stateDir = dirname\(managerEnvFile\(\)\)/);
+  assert.match(source, /cwd: stateDir/);
+  assert.match(source, /WIKI_MANAGER_ENV_FILE: managerEnvFile\(\)/);
+  assert.match(source, /WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile\(\)/);
+});
+
+test('container refresh pulls and renews only services that are already running', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  assert.match(script, /refresh_running_services\(\) \{/);
+  assert.match(script, /\[\[ -n "\$\{line\/\/\[\[:space:\]\]\/\}" \]\] \|\| continue/);
+  assert.match(script, /ps --status running --services/);
+  assert.match(script, /"\$@" pull "\$\{running_services\[@\]\}"/);
+  assert.match(script, /refresh_running_services 'No running external agent containers to refresh' 'Refreshed running agents: %s' _agents_dc/);
+  assert.match(script, /refresh_running_services "No running workspace containers to refresh: \$workspace" "Refreshed running workspace containers: \$workspace \(%s\)" compose_for_workspace "\$workspace"/);
+});

package/src/core/workflow.js

@@ -107,11 +107,83 @@ export function projectWorkflow(state = {}, events = []) {
     activity,
     waitingReasons,
     warnings,
+    usage: summarizeTokenUsage(events),
+    timingByTask: summarizeTaskTiming(events),
   };
   projected.graph = aggregateGraph(projected, events);
   return projected;
 }
 
+// Per-task wall-clock timing, derived from the lifecycle events. Start = the
+// first assigned/started event, finish = the last terminal event. Display-only
+// (the inspector shows duration + orders tasks into a temporal flow); never used
+// for scheduling.
+function summarizeTaskTiming(events = []) {
+  const byTask = {};
+  const START_EVENTS = new Set(['task.assigned', 'task.started']);
+  const END_EVENTS = new Set(['task.completed', 'task.failed', 'task.result_returned']);
+  for (const event of events) {
+    if (!START_EVENTS.has(event.type) && !END_EVENTS.has(event.type)) continue;
+    const taskId = String(event.taskId ?? event.payload?.taskId ?? '').replace(/^task:/, '');
+    if (!taskId) continue;
+    const ts = Number(new Date(event.ts).getTime());
+    if (!Number.isFinite(ts)) continue;
+    const entry = byTask[taskId] ?? (byTask[taskId] = { startedAt: null, finishedAt: null, durationMs: null });
+    if (START_EVENTS.has(event.type)) {
+      entry.startedAt = entry.startedAt == null ? ts : Math.min(entry.startedAt, ts);
+    } else {
+      entry.finishedAt = entry.finishedAt == null ? ts : Math.max(entry.finishedAt, ts);
+    }
+  }
+  for (const entry of Object.values(byTask)) {
+    if (entry.startedAt != null && entry.finishedAt != null && entry.finishedAt >= entry.startedAt) {
+      entry.durationMs = entry.finishedAt - entry.startedAt;
+    }
+  }
+  return byTask;
+}
+
+function summarizeTokenUsage(events = []) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let totalTokens = 0;
+  let inputKnown = false;
+  let outputKnown = false;
+  let totalKnown = false;
+  const byTask = {};
+  const seen = new Set();
+  for (const event of events) {
+    if (!['task.result_returned', 'task.completed', 'task.failed'].includes(event.type)) continue;
+    const result = event.payload?.result ?? {};
+    const metrics = result.metrics ?? event.payload?.metrics ?? {};
+    const attemptId = result.attemptId ?? event.payload?.attemptId ?? event.id;
+    if (attemptId && seen.has(attemptId)) continue;
+    if (attemptId) seen.add(attemptId);
+    const input = metricNumber(metrics.inputTokens ?? metrics.promptTokens ?? metrics.prompt_tokens);
+    const output = metricNumber(metrics.outputTokens ?? metrics.completionTokens ?? metrics.completion_tokens);
+    const total = metricNumber(metrics.totalTokens ?? metrics.total_tokens ?? metrics.tokens);
+    if (input != null) { inputTokens += input; inputKnown = true; }
+    if (output != null) { outputTokens += output; outputKnown = true; }
+    if (total != null) { totalTokens += total; totalKnown = true; }
+    else if (input != null || output != null) { totalTokens += (input ?? 0) + (output ?? 0); totalKnown = true; }
+    const taskId = String(event.taskId ?? event.payload?.taskId ?? '');
+    if (taskId && (input != null || output != null || total != null)) {
+      const current = byTask[taskId] ?? { inputTokens: 0, outputTokens: 0, totalTokens: 0, inputKnown: false, outputKnown: false, totalKnown: false };
+      if (input != null) { current.inputTokens += input; current.inputKnown = true; }
+      if (output != null) { current.outputTokens += output; current.outputKnown = true; }
+      current.totalTokens += total ?? ((input ?? 0) + (output ?? 0));
+      current.totalKnown = true;
+      byTask[taskId] = current;
+    }
+  }
+  return { inputTokens, outputTokens, totalTokens, inputKnown, outputKnown, totalKnown, byTask };
+}
+
+function metricNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : null;
+}
+
 function currentRun(state, events) {
   const runId = state.runId ?? state.runs?.find((run) => isActiveStatus(run.status))?.id ?? events.findLast?.((event) => event.runId)?.runId ?? null;
   if (!runId && !state.status) return null;

package/src/core/workflow.test.js

@@ -64,3 +64,60 @@ test('projectWorkflow reports approval and queue waiting reasons', () => {
   assert.ok(workflow.waitingReasons.includes('approval:approval-1'));
   assert.ok(workflow.waitingReasons.includes('queue:queued-1'));
 });
+
+test('projectWorkflow aggregates input and output tokens once per attempt', () => {
+  const state = {
+    status: 'done',
+    runId: 'run-usage',
+    plan: [{ id: 'build', description: 'Build', status: 'done' }],
+    activities: [],
+    queue: [],
+    approvals: [],
+  };
+  const result = {
+    attemptId: 'attempt-1',
+    metrics: { inputTokens: 1200, outputTokens: 300, totalTokens: 1500 },
+  };
+  const workflow = projectWorkflow(state, [
+    { id: 'event-1', type: 'task.result_returned', runId: 'run-usage', taskId: 'build', payload: { result } },
+    { id: 'event-2', type: 'task.completed', runId: 'run-usage', taskId: 'build', payload: { result } },
+  ]);
+
+  assert.deepEqual(workflow.usage, {
+    inputTokens: 1200,
+    outputTokens: 300,
+    totalTokens: 1500,
+    inputKnown: true,
+    outputKnown: true,
+    totalKnown: true,
+    byTask: {
+      build: {
+        inputTokens: 1200,
+        outputTokens: 300,
+        totalTokens: 1500,
+        inputKnown: true,
+        outputKnown: true,
+        totalKnown: true,
+      },
+    },
+  });
+});
+
+test('projectWorkflow derives per-task timing (start, finish, duration) from lifecycle events', () => {
+  const state = {
+    status: 'done',
+    runId: 'run-timing',
+    plan: [{ id: 'ingest', description: 'Ingest', status: 'done' }],
+    activities: [],
+    queue: [],
+    approvals: [],
+  };
+  const workflow = projectWorkflow(state, [
+    { id: 'e1', type: 'task.started', runId: 'run-timing', taskId: 'ingest', ts: '2026-07-23T10:00:00.000Z', payload: {} },
+    { id: 'e2', type: 'task.completed', runId: 'run-timing', taskId: 'ingest', ts: '2026-07-23T10:00:12.500Z', payload: {} },
+  ]);
+
+  assert.equal(workflow.timingByTask.ingest.startedAt, Date.parse('2026-07-23T10:00:00.000Z'));
+  assert.equal(workflow.timingByTask.ingest.finishedAt, Date.parse('2026-07-23T10:00:12.500Z'));
+  assert.equal(workflow.timingByTask.ingest.durationMs, 12500);
+});

package/src/core/workspaces.js

@@ -3,7 +3,7 @@ import { existsSync, readdirSync, realpathSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
-import { managerEnvFile, readEnvFile, userManagerDir } from './env.js';
+import { managerEnvFile, managerMcpEndpointsFile, readEnvFile, userManagerDir } from './env.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(__dirname, '../..');
@@ -70,15 +70,23 @@ export async function createWorkspace(name, targetPath = null, options = {}) {
   }
   const args = ['config', name];
   if (targetPath) args.push(targetPath);
+  const stateDir = dirname(managerEnvFile());
   const { stdout, stderr } = await execFileAsync(
     join(managerRoot(), 'wiki-workspace'),
     args,
     {
-      cwd: managerRoot(),
+      // Relative Compose mounts and default scaffold paths must resolve from
+      // the user's manager state, never from the globally installed package.
+      cwd: stateDir,
       env: {
         ...process.env,
         WIKI_WORKSPACES_DIR: workspacesDir(),
         WIKI_MANAGER_ENV_FILE: managerEnvFile(),
+        // The script runs from the installed package directory so it can find
+        // its Compose templates. Pin mutable manager state to the user's
+        // launch directory; a global npm package is commonly owned by root
+        // and must never become the destination for this scaffold.
+        WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
       },
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
       timeout: options.timeout ?? 600_000,

package/src/orchestrator/dependencyResolver.js

@@ -3,6 +3,9 @@ import { approvalCovered } from './approvalPolicy.js';
 
 const DONE_STATUSES = new Set(['done', 'completed', 'complete', 'success', 'succeeded']);
 const TERMINAL_STATUSES = new Set([...DONE_STATUSES, 'failed', 'cancelled', 'canceled', 'skipped']);
+// A task in one of these statuses hasn't run yet but could become ready —
+// shared with runner.js's scheduler-stall check so the two can't drift apart.
+export const PENDING_STATUSES = new Set(['pending', 'pending_approval', 'waiting_approval']);
 
 export function readyTasks(dag, {
   registry = null,
@@ -18,7 +21,7 @@ export function readyTasks(dag, {
     .filter((task) => {
       const status = statusOf(task);
       return status === 'pending'
-        || ((status === 'waiting_approval' || status === 'pending_approval')
+        || (PENDING_STATUSES.has(status)
           && approvalCovered(task, approvals, {
             runId: task?.runId ?? dag?.runId ?? null,
             workspaceId: dag?.workspace ?? null,
@@ -35,6 +38,21 @@ export function readyTasks(dag, {
     .sort(compareTaskPriority);
 }
 
+export function tasksAwaitingApproval(dag, { approvals = [] } = {}) {
+  const tasks = normalizeTasks(dag);
+  const done = new Set(tasks.filter((task) => DONE_STATUSES.has(statusOf(task))).map(taskId));
+  return tasks
+    .filter((task) => PENDING_STATUSES.has(statusOf(task)))
+    .filter((task) => task?.requiresApproval === true)
+    .filter((task) => !approvalCovered(task, approvals, {
+      runId: task?.runId ?? dag?.runId ?? null,
+      workspaceId: dag?.workspace ?? null,
+      planRevision: dag?.planRevision ?? null,
+    }))
+    .filter((task) => dependenciesDone(task, done))
+    .filter((task) => groupBarrierSatisfied(task, tasks));
+}
+
 function normalizeTasks(dag) {
   if (Array.isArray(dag)) return dag;
   if (Array.isArray(dag?.tasks)) return dag.tasks;

package/src/orchestrator/objectiveResolver.js

@@ -1,6 +1,8 @@
 export async function resolveObjective(objective, session) {
   const candidates = capabilityCandidates(session);
   if (candidates.length === 0) throw new Error('No orchestrable capability is currently available.');
+  const deterministic = resolveMentionedRegistryOperation(objective, candidates);
+  if (deterministic) return selectionWithProvider(session, deterministic, candidates);
   const llm = session?.llm;
   if (!llm?.completeWithTools) throw new Error('Objective resolution requires the configured workspace LLM.');
 
@@ -25,6 +27,28 @@ export async function resolveObjective(objective, session) {
   if (!candidate.operations.includes(operation)) {
     throw new Error(`Objective resolver selected unsupported operation "${operation}" for ${capability}.`);
   }
+  return selectionWithProvider(session, { capability, operation }, candidates);
+}
+
+// Prefer an operation explicitly named by the user when that name resolves to
+// exactly one entry in the live registry. This is deliberately generic: the
+// resolver knows neither capability ids nor business verbs. Prefix matching
+// covers natural inflections such as an operation name followed by a suffix.
+function resolveMentionedRegistryOperation(objective, candidates) {
+  const words = String(objective ?? '')
+    .normalize('NFKD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase()
+    .match(/[a-z0-9]+/g) ?? [];
+  const matches = candidates.flatMap((candidate) => candidate.operations
+    .filter((operation) => String(operation).split(/[._-]+/).some((token) =>
+      token.length >= 4 && words.some((word) => word.startsWith(token))))
+    .map((operation) => ({ capability: candidate.id, operation })));
+  return matches.length === 1 ? matches[0] : null;
+}
+
+function selectionWithProvider(session, selection, candidates) {
+  const { capability, operation } = selection;
   const providers = providersFor(session, capability)
     .filter((provider) => !operation || (provider.capability?.supportedOperations ?? []).includes(operation))
     .sort((a, b) => String(a.agentInstanceId).localeCompare(String(b.agentInstanceId)));