@linzumi/cli 1.0.34 → 1.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {

package/scripts/f3-planning-dag-e2e.mjs

@@ -0,0 +1,167 @@
+/*
+- Date: 2026-07-04
+  Spec: plans/2026-07-04-projects-followups-stack.md (F3)
+  Relationship: Behavioral execution proof for the F3 prompt: drives a REAL
+  Claude Code session (Claude Agent SDK, the same preset+append system-prompt
+  wiring claudeCodeSession.ts uses) with the compiled project-bound developer
+  instructions and the REAL shipped stdio Linzumi MCP server, starts the
+  session in plan mode, approves the plan-mode exit, and lets the prompt -
+  nothing else - drive the transfer of the plan into the project's task DAG.
+  Prints the full tool-call transcript. Pair with
+  scripts/f3-planning-dag-verify.mjs to snapshot/assert the resulting graph.
+
+  This intentionally exercises the PROMPT as the artifact under test: the
+  user prompt never mentions Linzumi, projects, tasks, or MCP tools.
+
+  Usage (see kandan/server_v2/scripts/f2_task_graph_mcp_seed.exs for seeding):
+    node scripts/f3-planning-dag-e2e.mjs \
+      --api-url http://127.0.0.1:4199 \
+      --seed-json '<output of the seed script>' \
+      --cwd /tmp/f3-demo-repo \
+      --prompt 'I want to add tagging and search. Plan it first.'
+*/
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const args = process.argv.slice(2);
+const argValue = (flag) => {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+};
+
+const apiUrl = argValue('--api-url') ?? 'http://127.0.0.1:4199';
+const seed = JSON.parse(argValue('--seed-json') ?? '{}');
+const cwd = argValue('--cwd') ?? '/tmp/f3-demo-repo';
+const userPrompt = argValue('--prompt');
+if (!seed.token || !seed.project_id || !userPrompt) {
+  console.error('missing --seed-json (token, project_id) or --prompt');
+  process.exit(2);
+}
+
+const packageRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..'
+);
+
+// Compile the exact production developer instructions for a project-bound
+// Claude Code job (planTool todo-write, projectBound true) via the real
+// compiler - no hand-written prompt text in this harness.
+// tsx may be hoisted to the workspace root by pnpm.
+const tsxBin = [
+  path.join(packageRoot, 'node_modules', '.bin', 'tsx'),
+  path.join(packageRoot, '..', '..', 'node_modules', '.bin', 'tsx'),
+].find((candidate) => existsSync(candidate));
+const compiled = spawnSync(
+  tsxBin,
+  [
+    '-e',
+    `import { commanderDeveloperInstructions } from './src/commanderDeveloperInstructions';
+process.stdout.write(commanderDeveloperInstructions({
+  cwd: ${JSON.stringify(cwd)},
+  agentLabel: 'Claude Code',
+  planTool: 'todo-write',
+  developerPrompt: undefined,
+  projectBound: true,
+  linzumiContext: undefined,
+}));`,
+  ],
+  { cwd: packageRoot, encoding: 'utf8' }
+);
+if (compiled.status !== 0) {
+  console.error('failed to compile developer instructions:', compiled.stderr);
+  process.exit(2);
+}
+const developerInstructions = compiled.stdout;
+console.log(
+  `=== compiled developer instructions: ${developerInstructions.length} chars, ` +
+    `projectBound directives present: ${developerInstructions.includes('project task DAG')}`
+);
+
+const toolCalls = [];
+let exitPlanModeSeen = false;
+
+const session = query({
+  prompt: userPrompt,
+  options: {
+    cwd,
+    // Production wiring parity (claudeCodeSession.ts): preset system prompt
+    // with the compiled Commander developer instructions appended.
+    systemPrompt: {
+      type: 'preset',
+      preset: 'claude_code',
+      append: developerInstructions,
+    },
+    // The user chose plan mode for this planning session.
+    permissionMode: 'plan',
+    allowedTools: ['mcp__linzumi__*'],
+    mcpServers: {
+      linzumi: {
+        type: 'stdio',
+        command: process.execPath,
+        args: [
+          path.join(packageRoot, 'bin', 'linzumi.js'),
+          'mcp',
+          'server',
+          '--api-url',
+          apiUrl,
+          '--mode',
+          'text',
+          '--tool-scope',
+          'all',
+        ],
+        env: {
+          ...process.env,
+          LINZUMI_MCP_ACCESS_TOKEN: seed.token,
+        },
+      },
+    },
+    // Approve the plan-mode exit (the human accepting the plan) and demo-repo
+    // edits; the DAG transfer itself must be prompt-driven, not approved into
+    // existence - MCP tools are already trusted via allowedTools.
+    canUseTool: async (toolName, input) => {
+      if (toolName === 'ExitPlanMode') {
+        exitPlanModeSeen = true;
+        console.log('\n=== ExitPlanMode requested; approving (plan accepted)');
+      }
+      return { behavior: 'allow', updatedInput: input };
+    },
+  },
+});
+
+for await (const message of session) {
+  if (message.type === 'assistant') {
+    for (const block of message.message.content ?? []) {
+      if (block.type === 'tool_use') {
+        toolCalls.push(block.name);
+        const summary =
+          block.name.startsWith('mcp__linzumi__') ||
+          block.name === 'ExitPlanMode'
+            ? JSON.stringify(block.input).slice(0, 400)
+            : '';
+        console.log(`[tool_use] ${block.name} ${summary}`);
+      } else if (block.type === 'text' && block.text.trim() !== '') {
+        console.log(`[assistant] ${block.text.slice(0, 600)}`);
+      }
+    }
+  } else if (message.type === 'result') {
+    console.log(`\n=== result: ${message.subtype}; turns=${message.num_turns}`);
+  }
+}
+
+const dagCalls = toolCalls.filter((name) =>
+  name.startsWith('mcp__linzumi__linzumi_')
+);
+console.log('\n=== summary');
+console.log(`ExitPlanMode seen: ${exitPlanModeSeen}`);
+console.log(`linzumi MCP calls: ${JSON.stringify(dagCalls)}`);
+const reviewedFirst =
+  dagCalls.findIndex((name) => name.includes('get_project_tasks')) !== -1 &&
+  dagCalls.findIndex((name) => name.includes('get_project_tasks')) <
+    Math.max(
+      0,
+      dagCalls.findIndex((name) => name.includes('create_project_task'))
+    );
+console.log(`reviewed project state before creating: ${reviewedFirst}`);

package/scripts/f3-planning-dag-verify.mjs

@@ -0,0 +1,130 @@
+/*
+- Date: 2026-07-04
+  Spec: plans/2026-07-04-projects-followups-stack.md (F3)
+  Relationship: DAG snapshot + negative-guarantee verifier for the F3
+  behavioral proof (scripts/f3-planning-dag-e2e.mjs). Reads the project graph
+  through the REAL shipped stdio MCP server and either prints a snapshot
+  (--snapshot out.json) or asserts guarantees against a prior snapshot
+  (--baseline prior.json): a named user-created task survives untouched
+  (--user-task "title"), no duplicate titles appear, and baseline tasks were
+  updated rather than deleted (every baseline id still present).
+
+  Usage:
+    node scripts/f3-planning-dag-verify.mjs --api-url ... --seed-json '...' \
+      --snapshot after-session-1.json --user-task "Write launch announcement" \
+      [--baseline after-session-0.json]
+*/
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { fileURLToPath } from 'node:url';
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+
+const args = process.argv.slice(2);
+const argValue = (flag) => {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+};
+
+const apiUrl = argValue('--api-url') ?? 'http://127.0.0.1:4199';
+const seed = JSON.parse(argValue('--seed-json') ?? '{}');
+const snapshotPath = argValue('--snapshot');
+const baselinePath = argValue('--baseline');
+const userTaskTitle = argValue('--user-task');
+if (!seed.token || !seed.project_id) {
+  console.error('missing --seed-json (token, project_id)');
+  process.exit(2);
+}
+
+const packageRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..'
+);
+
+let failures = 0;
+const check = (label, condition) => {
+  const mark = condition ? 'PASS' : 'FAIL';
+  if (!condition) failures += 1;
+  console.log(`  [${mark}] ${label}`);
+};
+
+const client = new Client({ name: 'f3-dag-verify', version: '0.0.0' });
+const transport = new StdioClientTransport({
+  command: process.execPath,
+  args: [
+    path.join(packageRoot, 'bin', 'linzumi.js'),
+    'mcp',
+    'server',
+    '--api-url',
+    apiUrl,
+    '--mode',
+    'text',
+    '--tool-scope',
+    'all',
+  ],
+  env: { ...process.env, LINZUMI_MCP_ACCESS_TOKEN: seed.token },
+});
+await client.connect(transport);
+
+const result = await client.callTool({
+  name: 'linzumi_get_project_tasks',
+  arguments: { project_id: seed.project_id },
+});
+const graph = JSON.parse(result.content?.[0]?.text ?? '{}');
+const tasks = graph.tasks ?? [];
+
+console.log('=== project task DAG snapshot');
+const byId = new Map(tasks.map((task) => [task.task_id, task]));
+let edgeCount = 0;
+for (const task of tasks) {
+  const parent = task.parent_task_id
+    ? byId.get(task.parent_task_id)?.title
+    : undefined;
+  const deps = (task.depends_on_task_ids ?? [])
+    .map((dep) => byId.get(dep)?.title ?? dep)
+    .join(', ');
+  edgeCount += (task.depends_on_task_ids ?? []).length;
+  console.log(
+    `  [${task.kind}] "${task.title}"` +
+      (parent ? ` (in "${parent}")` : '') +
+      (task.status ? ` status=${task.status}` : '') +
+      (task.work_state ? ` work_state=${task.work_state}` : '') +
+      (deps ? ` blocked-by: ${deps}` : '')
+  );
+}
+console.log(`  total: ${tasks.length} tasks, ${edgeCount} dependency edges`);
+
+if (snapshotPath) {
+  writeFileSync(snapshotPath, JSON.stringify(graph, null, 2));
+  console.log(`snapshot written: ${snapshotPath}`);
+}
+
+console.log('\n=== guarantees');
+if (userTaskTitle) {
+  check(
+    `user-created task "${userTaskTitle}" still present (never deleted)`,
+    tasks.some((task) => task.title === userTaskTitle)
+  );
+}
+const titles = tasks.map((task) => task.title);
+check(
+  'no duplicate task titles (updated, not re-created)',
+  new Set(titles).size === titles.length
+);
+if (baselinePath) {
+  const baseline = JSON.parse(readFileSync(baselinePath, 'utf8'));
+  const baselineTasks = baseline.tasks ?? [];
+  const currentIds = new Set(tasks.map((task) => task.task_id));
+  for (const prior of baselineTasks) {
+    check(
+      `baseline task "${prior.title}" (id ${prior.task_id}) not deleted`,
+      currentIds.has(prior.task_id)
+    );
+  }
+  console.log(
+    `baseline: ${baselineTasks.length} tasks; current: ${tasks.length} tasks`
+  );
+}
+
+await client.close();
+process.exit(failures === 0 ? 0 : 1);