@dotdrelle/wiki-manager 0.14.12 → 0.14.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.14.12",
+  "version": "0.14.13",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/core/activity.js

@@ -31,6 +31,9 @@ function normalizePlanSteps(steps) {
     executor: s?.executor ?? null,
     executorQuery: s?.executorQuery ?? null,
     outputRefs: Array.isArray(s?.outputRefs) ? s.outputRefs.map(String) : [],
+    ...(s?.status != null ? { status: String(s.status) } : {}),
+    ...(s?.startedAt != null ? { startedAt: s.startedAt } : {}),
+    ...(s?.finishedAt != null ? { finishedAt: s.finishedAt } : {}),
   }));
 }
 
@@ -149,6 +152,7 @@ function productionActivityFromPayload(payload, context = {}) {
       step,
       ...(payload?.taskId ? { stepId: String(payload.taskId) } : {}),
     },
+    plan: Array.isArray(progress?.steps) ? { steps: progress.steps } : null,
     poll: jobId ? {
       server: 'production',
       tool: context.tool === 'agent_status' ? 'agent_status' : 'production_job_status',

package/src/core/activity.test.js

@@ -109,6 +109,37 @@ test('extractActivity: documents conversion activity carries plan and percent',
   assert.deepEqual(activity.plan.steps.map((step) => step.id), ['resolve', 'convert', 'write']);
 });
 
+test('extractActivity: agent_status carries structured processing progress', () => {
+  const activity = extractActivity({
+    jobId: 'job-build',
+    taskId: 'build-report',
+    operation: 'build',
+    status: 'running',
+    progress: {
+      percent: 47,
+      phase: 'build',
+      detail: 'Batch 2/4 · LLM throttled',
+      stepIndex: 1,
+      stepTotal: 2,
+      steps: [
+        { id: 'build', name: 'build', status: 'running' },
+        { id: 'export', name: 'export', status: 'pending' },
+      ],
+      batch: { index: 2, total: 4, status: 'running' },
+      throttling: { active: true, waitMs: 1200, retryAt: '2026-07-21T10:00:01Z' },
+      processing: { instructionCount: 8 },
+    },
+  }, { server: 'production', tool: 'agent_status' });
+
+  assert.deepEqual(activity.plan.steps.map((step) => [step.id, step.status]), [
+    ['build', 'running'],
+    ['export', 'pending'],
+  ]);
+  assert.equal(activity.progress.batch.index, 2);
+  assert.equal(activity.progress.throttling.active, true);
+  assert.equal(activity.progress.processing.instructionCount, 8);
+});
+
 test('rememberActivity: returns normalized activity on success', () => {
   const session = {};
   const result = rememberActivity(session, { id: '1', status: 'running', source: 'x', kind: 'job' });

package/src/core/agentEvents.js

@@ -122,13 +122,22 @@ export function resetSessionProjection(session) {
 
 function withSessionRunIdentity(event, session) {
   const identity = session?._currentRunIdentity;
-  if (!identity) return event;
+  // The workspace must be attached even OUTSIDE a run identity: the SSE
+  // publisher drops events whose workspace does not match the (always
+  // workspace-scoped) serve UI client. Events dispatched between chained
+  // executions — e.g. the plan_set of the next action, run evaluation,
+  // assistant messages — used to leave with workspace=null and never reached
+  // the UI, which then displayed a stale plan from the previous action.
+  const workspace = event.workspace ?? identity?.workspace ?? session?.workspace ?? null;
+  if (!identity) {
+    return workspace === (event.workspace ?? null) ? event : { ...event, workspace };
+  }
   return {
     ...event,
     runId: event.runId ?? identity.runId ?? null,
     turnId: event.turnId ?? identity.turnId ?? null,
     taskId: event.taskId ?? identity.taskId ?? null,
-    workspace: event.workspace ?? identity.workspace ?? null,
+    workspace,
   };
 }
 

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.14.12",
-  "commit": "621830d"
+  "version": "0.14.13",
+  "commit": "f0faf8b"
 }

package/src/core/env.js

@@ -98,14 +98,26 @@ export function ensureManagerScaffold({ log = () => {} } = {}) {
   return created;
 }
 
+// Mirrors workspacesDir() in core/workspaces.js (which imports this module,
+// so it cannot be imported here without a cycle).
+function workspacesRootDir() {
+  return process.env.WIKI_WORKSPACES_DIR
+    ? resolve(process.env.WIKI_WORKSPACES_DIR)
+    : join(userManagerDir(), 'workspaces');
+}
+
 // Single source of truth for where `.agents-data` lives, shared by the
-// manager's own document intake and by the host path it mounts into agent
-// containers — keeping them in sync avoids the two silently drifting apart.
+// manager's own document intake, the per-workspace serve stack, and the
+// GLOBAL agents stack (documents/cme containers). All three must resolve the
+// same host directory: serve writes an upload into its mount and the
+// documents container must find it under the identical path — a divergence
+// here is exactly the clean-install "Input file does not exist" bug.
+// Canonical location: `<workspaces root>/.agents-data`, session or not.
 export function resolveAgentsDataDir(session = null) {
   const configured = process.env.AGENTS_DATA_DIR;
-  if (configured) return isAbsolute(configured) ? configured : resolve(defaultRuntimeStateDir(), configured);
+  if (configured) return isAbsolute(configured) ? configured : resolve(managerStateDir(), configured);
   if (session?.workspacePath) return resolve(dirname(session.workspacePath), '.agents-data');
-  return resolve(defaultRuntimeStateDir(), 'agents-data');
+  return resolve(workspacesRootDir(), '.agents-data');
 }
 
 function parseEnvValue(value) {

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.12';
+const WIKI_MANAGER_VERSION = '0.14.13';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/wikiSetup.js

@@ -6,7 +6,7 @@ import { promisify } from 'node:util';
 import YAML from 'yaml';
 import { checkMissingDockerImages } from './dockerImages.js';
 import { patchWikircProfile } from './wikirc.js';
-import { managerEnvFile, managerMcpEndpointsFile } from './env.js';
+import { managerEnvFile, managerMcpEndpointsFile, resolveAgentsDataDir } from './env.js';
 import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
 
 const execFileAsync = promisify(execFile);
@@ -68,6 +68,12 @@ export async function startAgents(options = {}) {
         // user's .env stayed empty on a fresh install.
         WIKI_MANAGER_ENV_FILE: managerEnvFile(),
         WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
+        // Same pinning for .agents-data: without it the script defaults to
+        // $PWD/.agents-data (the PACKAGE directory), while the serve stack
+        // mounts the workspace-root .agents-data — the documents container
+        // then reads an empty input dir and every conversion fails with
+        // "Input file does not exist" on a clean install.
+        AGENTS_DATA_DIR: resolveAgentsDataDir(),
       },
       timeout: options.timeout ?? 180_000,
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
@@ -88,6 +94,7 @@ export async function stopAgents(options = {}) {
       env: {
         ...process.env,
         WIKI_WORKSPACES_DIR: workspacesDir(),
+        AGENTS_DATA_DIR: resolveAgentsDataDir(),
       },
       timeout: options.timeout ?? 120_000,
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,

package/src/runtime/runner.js

@@ -607,8 +607,25 @@ function failedTaskActivities(session) {
   return failedKeys.size > 0 ? all.filter((activity) => failedKeys.has(activity.key)) : all;
 }
 
-function ensurePlanProjection(session, runId) {
-  if (!session.headlessPlan || session.agentProjection?.plan) return;
+// Identity of a plan as displayed: the ordered list of task ids. Two plans
+// with the same tasks in the same order are the same plan for projection
+// purposes (statuses update through plan_step_updated, not a re-projection).
+function planIdentitySignature(plan) {
+  return Array.isArray(plan) ? plan.map(planTaskId).join('|') : '';
+}
+
+export function ensurePlanProjection(session, runId) {
+  if (!session.headlessPlan) return;
+  // Re-emit plan_set not only when the projection has no plan yet, but also
+  // when the session plan has CHANGED shape since the last projection. A
+  // chained run (e.g. /skill pipeline) sets a fresh headlessPlan for step 2
+  // while the projection still holds step 1's plan; the old guard
+  // (`agentProjection?.plan` truthy → skip) then left the UI stuck on the
+  // step 1 plan. Compare task identities and re-project when they differ.
+  const projected = session.agentProjection?.plan ?? null;
+  if (projected && planIdentitySignature(projected) === planIdentitySignature(session.headlessPlan)) {
+    return;
+  }
   dispatchAgentEvent(session, createAgentEvent('plan_set', {
     origin: 'runtime',
     runId,

package/src/runtime/runner.test.js

@@ -1,7 +1,38 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler } from './runner.js';
+import { ensurePlanProjection, evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler } from './runner.js';
+
+test('ensurePlanProjection re-projects when the chained plan changes shape (step 2)', () => {
+  const session = { agentEvents: [], agentProjection: null };
+  // Step 1: a fresh plan is projected.
+  session.headlessPlan = [{ id: 'a', description: 'ingest', status: 'pending' }];
+  ensurePlanProjection(session, 'run-1');
+  assert.deepEqual(
+    (session.agentProjection?.plan ?? []).map((step) => step.id),
+    ['a'],
+  );
+
+  // Step 1 completes in place — same plan shape, no re-projection needed.
+  session.headlessPlan = [{ id: 'a', description: 'ingest', status: 'done' }];
+  const eventsAfterStep1 = session.agentEvents.length;
+  ensurePlanProjection(session, 'run-1');
+  assert.equal(session.agentEvents.length, eventsAfterStep1, 'unchanged shape must not re-emit plan_set');
+
+  // Step 2 adds a task — the projection must now reflect the new plan.
+  session.headlessPlan = [
+    { id: 'a', description: 'ingest', status: 'done' },
+    { id: 'b', description: 'build', status: 'pending' },
+  ];
+  ensurePlanProjection(session, 'run-1');
+  assert.deepEqual(
+    (session.agentProjection?.plan ?? []).map((step) => step.id),
+    ['a', 'b'],
+    'step 2 plan must be projected instead of staying on step 1',
+  );
+  // Completed step 1 status is preserved through the re-projection.
+  assert.equal(session.agentProjection.plan.find((step) => step.id === 'a').status, 'done');
+});
 
 test('validated tasks waiting for approval stay in the scheduler instead of falling back to Donna', () => {
   assert.equal(shouldUseParallelScheduler([

package/wiki-workspace

@@ -210,8 +210,11 @@ agents_compose() {
   [[ -f "$agents_compose_file" ]] || die "agents compose file not found: $agents_compose_file"
 
   local agents_data_dir workspaces_root
-  agents_data_dir="$(absolute_path "${AGENTS_DATA_DIR:-.agents-data}" "$DEFAULT_MANAGER_DIR")"
   workspaces_root="$(absolute_path "$WORKSPACES_DIR" "$DEFAULT_MANAGER_DIR")"
+  # Canonical .agents-data lives next to the workspaces (same rule as the
+  # manager's resolveAgentsDataDir): the serve stack and the agents stack MUST
+  # mount the same host directory or document conversions break.
+  agents_data_dir="$(absolute_path "${AGENTS_DATA_DIR:-$workspaces_root/.agents-data}" "$DEFAULT_MANAGER_DIR")"
 
   local compose_env_args=()
   [[ -f "$MANAGER_ENV_FILE" ]] && compose_env_args+=(--env-file "$MANAGER_ENV_FILE")
@@ -709,7 +712,8 @@ compose_for_workspace() {
   mcp_port="$(workspace_value "$workspace" WIKI_MCP_PORT 3101)"
   prod_port="$(workspace_value "$workspace" PRODUCTION_MCP_PORT 3102)"
   project="$(compose_project "$workspace")"
-  agents_data_dir="$(absolute_path "${AGENTS_DATA_DIR:-.agents-data}" "$DEFAULT_MANAGER_DIR")"
+  # Same canonical rule as agents_compose: .agents-data next to the workspaces.
+  agents_data_dir="$(absolute_path "${AGENTS_DATA_DIR:-$(dirname "$ws_path")/.agents-data}" "$DEFAULT_MANAGER_DIR")"
 
   local compose_env_args=()
   [[ -f "$MANAGER_ENV_FILE" ]] && compose_env_args+=(--env-file "$MANAGER_ENV_FILE")
@@ -920,7 +924,8 @@ config_workspace() {
   [[ -f "$env_file" ]] && die "workspace already configured: $env_file"
 
   local port_base serve_port mcp_port prod_port wiki_token prod_token agents_data_dir
-  agents_data_dir="$(absolute_path "${AGENTS_DATA_DIR:-.agents-data}" "$DEFAULT_MANAGER_DIR")"
+  # Same canonical rule as agents_compose: .agents-data next to the workspaces.
+  agents_data_dir="$(absolute_path "${AGENTS_DATA_DIR:-$(dirname "$target_path")/.agents-data}" "$DEFAULT_MANAGER_DIR")"
   port_base="$(find_free_workspace_port_base 3100)"
   serve_port="$port_base"
   mcp_port=$((port_base + 1))