@ai-content-space/loopx 0.1.1 → 0.1.3

package/src/cli.mjs

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 
-import { autopilotStage, approveStage, buildStage, clarifyStage, initWorkspace, planStage, reviewStage, statusSummary } from './workflow.mjs';
+import { archiveStage, autopilotStage, approveStage, buildStage, clarifyStage, initWorkspace, planStage, reviewStage, statusSummary } from './workflow.mjs';
 import { installBundledSkills } from './install-discovery.mjs';
+import { nextSkillCommand, withNextSkill } from './next-skill.mjs';
 import { doctorRuntime, migrateLegacyRuntime } from './runtime-maintenance.mjs';
+import { setupWorkspaceContext } from './workspace-context.mjs';
 
 function usage() {
   return [
@@ -12,9 +14,12 @@ function usage() {
     '  loopx approve <slug> --from <stage> --to <stage>',
     '  loopx plan [slug] [--direct <spec-path>] [--interactive] [--deliberate]',
     '  loopx build <slug> [--no-deslop]',
+    '  loopx build --from-review <review-report-path> [--no-deslop]',
     '  loopx review <slug> [--reviewer <name>]',
+    '  loopx archive <slug>',
     '  loopx autopilot <slug> [--reviewer <name>]',
     '  loopx status [slug] [--json]',
+    '  loopx setup-context',
     '  loopx doctor',
     '  loopx migrate',
     '  loopx repair-install',
@@ -77,7 +82,7 @@ function printHumanStatus(status) {
     console.log(`plan_deliberate_mode: ${status.state.plan_deliberate_mode}`);
     console.log(`plan_architect_review_status: ${status.state.plan_architect_review_status}`);
     console.log(`plan_critic_verdict: ${status.state.plan_critic_verdict}`);
-    console.log(`plan_docs_status: ${status.state.plan_docs_status}`);
+    console.log(`plan_artifact_status: ${status.state.plan_docs_status}`);
     console.log(`plan_blockers: ${Array.isArray(status.state.plan_blockers) && status.state.plan_blockers.length > 0 ? status.state.plan_blockers.join(', ') : '(none)'}`);
   }
   if (status.state?.current_stage === 'build') {
@@ -87,8 +92,31 @@ function printHumanStatus(status) {
     console.log(`build_architect_verification_status: ${status.state.build_architect_verification_status}`);
     console.log(`build_deslop_status: ${status.state.build_deslop_status}`);
     console.log(`build_regression_status: ${status.state.build_regression_status}`);
+    console.log(`context_manifest_status: ${status.state.context_manifest_status ?? 'unknown'}`);
     console.log(`build_blockers: ${Array.isArray(status.state.build_blockers) && status.state.build_blockers.length > 0 ? status.state.build_blockers.join(', ') : '(none)'}`);
   }
+  if (status.state?.workspace_journal_path) {
+    console.log(`workspace_journal_path: ${status.state.workspace_journal_path}`);
+  }
+  if (status.state?.change_artifacts_status) {
+    console.log(`change_artifacts_status: ${status.state.change_artifacts_status}`);
+    console.log(`spec_delta_status: ${status.state.spec_delta_status ?? 'unknown'}`);
+    console.log(`spec_sync_status: ${status.state.spec_sync_status ?? 'unknown'}`);
+    console.log(`archive_status: ${status.state.archive_status ?? 'unknown'}`);
+  }
+  if (status.state?.readiness && status.state?.authorization) {
+    for (const key of ['plan', 'build', 'review', 'done', 'archive']) {
+      if (status.state.readiness[key]) {
+        console.log(`readiness_${key}: ${status.state.readiness[key].ready}`);
+      }
+      if (status.state.authorization[key]) {
+        console.log(`authorization_${key}: ${status.state.authorization[key].authorized}`);
+      }
+    }
+  }
+  if (status.hook) {
+    console.log(`hook_enabled: ${status.hook.enabled}`);
+  }
   if (status.state?.autopilot_current_phase && status.state.autopilot_current_phase !== 'none') {
     console.log(`autopilot_current_phase: ${status.state.autopilot_current_phase}`);
     console.log(`autopilot_completed: ${status.state.autopilot_completed}`);
@@ -98,6 +126,10 @@ function printHumanStatus(status) {
   console.log(`last_confirmed_transition: ${status.state?.last_confirmed_transition ?? 'none'}`);
   console.log(`pending_user_decision: ${status.state?.pending_user_decision ?? 'none'}`);
   console.log(`missing artifacts: ${status.missing_artifacts.length > 0 ? status.missing_artifacts.join(', ') : '(none)'}`);
+  const nextSkill = nextSkillCommand(status.state);
+  if (nextSkill) {
+    console.log(`next skill: ${nextSkill}`);
+  }
   console.log(`next: ${status.next_action}`);
 }
 
@@ -115,10 +147,15 @@ async function main() {
         console.log(JSON.stringify({ ok: true, command, workspaceRoot: result.workspaceRoot, workflow: result.workflow?.state ?? null }, null, 2));
         return;
       }
+      case 'setup-context': {
+        const contextSetup = await setupWorkspaceContext(process.cwd());
+        console.log(JSON.stringify({ ok: true, command, contextSetup }, null, 2));
+        return;
+      }
       case 'clarify': {
         const profile = options.get('--deep') ? 'deep' : 'standard';
         const result = await clarifyStage(process.cwd(), positionals[0], { profile });
-        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state }, null, 2));
+        console.log(JSON.stringify(withNextSkill({ ok: true, command, root: result.root, state: result.state }, result.state), null, 2));
         return;
       }
       case 'approve': {
@@ -126,7 +163,7 @@ async function main() {
           from: options.get('--from'),
           to: options.get('--to'),
         });
-        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state }, null, 2));
+        console.log(JSON.stringify(withNextSkill({ ok: true, command, root: result.root, state: result.state }, result.state), null, 2));
         return;
       }
       case 'plan': {
@@ -135,21 +172,27 @@ async function main() {
           interactive: Boolean(options.get('--interactive')),
           deliberate: Boolean(options.get('--deliberate')),
         });
-        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state }, null, 2));
+        console.log(JSON.stringify(withNextSkill({ ok: true, command, root: result.root, state: result.state }, result.state), null, 2));
         return;
       }
       case 'build': {
-        const result = await buildStage(process.cwd(), positionals[0], {
+        const result = await buildStage(process.cwd(), options.get('--from-review') ? undefined : positionals[0], {
           noDeslop: Boolean(options.get('--no-deslop')),
+          fromReviewPath: options.get('--from-review'),
         });
-        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state }, null, 2));
+        console.log(JSON.stringify(withNextSkill({ ok: true, command, root: result.root, state: result.state }, result.state), null, 2));
         return;
       }
       case 'review': {
         const result = await reviewStage(process.cwd(), positionals[0], {
           reviewer: options.get('--reviewer') || 'independent-reviewer',
         });
-        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state, verdict: result.verdict }, null, 2));
+        console.log(JSON.stringify(withNextSkill({ ok: true, command, root: result.root, state: result.state, verdict: result.verdict, review_message_zh: result.reviewMessageZh }, result.state), null, 2));
+        return;
+      }
+      case 'archive': {
+        const result = await archiveStage(process.cwd(), positionals[0]);
+        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state }, null, 2));
         return;
       }
       case 'autopilot': {

package/src/codex-exec-runtime.mjs

@@ -1,9 +1,16 @@
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, unlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 const DEFAULT_CODEX_MODEL = 'gpt-5.4';
 const DEFAULT_CODEX_TIMEOUT_MS = 120000;
 const DEFAULT_CODEX_REASONING = 'low';
+const DIAGNOSTIC_TAIL_CHARS = 4000;
+
+function diagnosticTail(value) {
+  return String(value || '').slice(-DIAGNOSTIC_TAIL_CHARS);
+}
 
 function codexBinary() {
   return process.env.LOOPX_CODEX_BIN || 'codex';
@@ -22,7 +29,14 @@ export async function runCodexExec({
   extraArgs = [],
   timeoutMs = DEFAULT_CODEX_TIMEOUT_MS,
   reasoningEffort = DEFAULT_CODEX_REASONING,
+  outputSchema = null,
+  promptViaStdin = false,
 }) {
+  await unlink(outputPath).catch((error) => {
+    if (error?.code !== 'ENOENT') {
+      throw error;
+    }
+  });
   const args = [
     'exec',
     '--dangerously-bypass-approvals-and-sandbox',
@@ -34,8 +48,9 @@ export async function runCodexExec({
     `model_reasoning_effort=\"${reasoningEffort}\"`,
     '-o',
     outputPath,
+    ...(outputSchema ? ['--output-schema', outputSchema] : []),
     ...extraArgs,
-    prompt,
+    promptViaStdin ? '-' : prompt,
   ];
 
   const child = spawn(codexBinary(), args, {
@@ -47,14 +62,16 @@ export async function runCodexExec({
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 
-  child.stdin.end();
+  child.stdin.end(promptViaStdin ? prompt : undefined);
 
   const stdoutChunks = [];
   const stderrChunks = [];
   child.stdout.on('data', (chunk) => stdoutChunks.push(Buffer.from(chunk)));
   child.stderr.on('data', (chunk) => stderrChunks.push(Buffer.from(chunk)));
 
+  let timedOut = false;
   const timeout = setTimeout(() => {
+    timedOut = true;
     child.kill('SIGTERM');
   }, timeoutMs);
 
@@ -67,6 +84,9 @@ export async function runCodexExec({
     const stdout = Buffer.concat(stdoutChunks).toString('utf8');
     const stderr = Buffer.concat(stderrChunks).toString('utf8');
     const finalMessage = existsSync(outputPath) ? await readFile(outputPath, 'utf8') : '';
+    if (timedOut) {
+      throw new Error('timeout');
+    }
     if (exitCode !== 0) {
       throw new Error(`exit_${exitCode}`);
     }
@@ -82,7 +102,7 @@ export async function runCodexExec({
     const stderr = Buffer.concat(stderrChunks).toString('utf8');
     const finalMessage = existsSync(outputPath) ? await readFile(outputPath, 'utf8') : '';
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`codex_exec_failed:${message}\nstdout:${stdout}\nstderr:${stderr}\nfinal:${finalMessage}`);
+    throw new Error(`codex_exec_failed:${message}\nstdout:${diagnosticTail(stdout)}\nstderr:${diagnosticTail(stderr)}\nfinal:${diagnosticTail(finalMessage)}`);
   }
 }
 
@@ -92,6 +112,86 @@ export async function runCodexExecJson(options) {
   try {
     return JSON.parse(text);
   } catch (error) {
-    throw new Error(`codex_exec_invalid_json:${error instanceof Error ? error.message : String(error)}\nbody:${text}`);
+    const stdout = diagnosticTail(result.stdout);
+    const stderr = diagnosticTail(result.stderr);
+    throw new Error(`codex_exec_invalid_json:${error instanceof Error ? error.message : String(error)}\nbody:${text}\nstdout:${stdout}\nstderr:${stderr}`);
+  }
+}
+
+export async function runCodexReviewJson({
+  cwd,
+  prompt,
+  outputPath,
+  model = DEFAULT_CODEX_MODEL,
+  timeoutMs = DEFAULT_CODEX_TIMEOUT_MS,
+  reasoningEffort = DEFAULT_CODEX_REASONING,
+  uncommitted = true,
+  outputSchema = null,
+}) {
+  let schemaDir = null;
+  let schemaPath = outputSchema;
+  try {
+    if (!schemaPath) {
+      schemaDir = await mkdtemp(join(tmpdir(), 'loopx-code-review-schema-'));
+      schemaPath = join(schemaDir, 'schema.json');
+      await writeFile(schemaPath, JSON.stringify({
+        type: 'object',
+        additionalProperties: false,
+        required: ['status', 'verdict', 'summary', 'findings'],
+        properties: {
+          status: { enum: ['complete', 'skipped'] },
+          verdict: { enum: ['approve', 'request-changes'] },
+          summary: { type: 'string' },
+          rollbackTarget: {
+            anyOf: [
+              { enum: ['build', 'plan', 'clarify'] },
+              { type: 'null' },
+            ],
+          },
+          findings: {
+            type: 'array',
+            items: {
+              type: 'object',
+              additionalProperties: false,
+              required: ['severity', 'file', 'line', 'message'],
+              properties: {
+                severity: { enum: ['high', 'medium', 'low'] },
+                file: { anyOf: [{ type: 'string' }, { type: 'null' }] },
+                line: { anyOf: [{ type: 'number' }, { type: 'null' }] },
+                message: { type: 'string' },
+              },
+            },
+          },
+        },
+      }));
+    }
+    try {
+      return await runCodexExecJson({
+        cwd,
+        prompt,
+        outputPath,
+        model,
+        timeoutMs,
+        reasoningEffort,
+        outputSchema: schemaPath,
+        promptViaStdin: true,
+        extraArgs: uncommitted ? [] : [],
+      });
+    } catch (error) {
+      return await runCodexExecJson({
+        cwd,
+        prompt,
+        outputPath,
+        model,
+        timeoutMs,
+        reasoningEffort,
+        promptViaStdin: true,
+        extraArgs: uncommitted ? [] : [],
+      });
+    }
+  } finally {
+    if (schemaDir) {
+      await rm(schemaDir, { recursive: true, force: true });
+    }
   }
 }

package/src/context-manifest.mjs

@@ -0,0 +1,172 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+
+import { inspectWorkspaceContext, resolveWorkspaceContextPaths } from './workspace-context.mjs';
+
+export const CONTEXT_MANIFEST_SCHEMA_VERSION = 1;
+const MAX_MANIFEST_ROWS = 80;
+
+function normalizePath(cwd, path) {
+  const resolved = resolve(path);
+  const rel = relative(cwd, resolved);
+  return rel && !rel.startsWith('..') ? rel : resolved;
+}
+
+function normalizeReason(reason) {
+  if (Array.isArray(reason)) {
+    return reason.filter(Boolean).map(String).join(',');
+  }
+  return String(reason || 'context');
+}
+
+function row(cwd, { stage, kind, path, reason, priority, required = true }) {
+  const normalizedPath = normalizePath(cwd, path);
+  return {
+    schema_version: CONTEXT_MANIFEST_SCHEMA_VERSION,
+    stage,
+    kind,
+    path: normalizedPath,
+    reason: normalizeReason(reason),
+    priority,
+    required: Boolean(required),
+    exists: existsSync(resolve(cwd, normalizedPath)),
+  };
+}
+
+function stableRows(rows) {
+  const byPath = new Map();
+  for (const item of rows) {
+    const key = `${item.stage}:${item.kind}:${item.path}`;
+    const existing = byPath.get(key);
+    if (!existing) {
+      byPath.set(key, item);
+      continue;
+    }
+    const reasons = new Set([
+      ...existing.reason.split(',').map((value) => value.trim()).filter(Boolean),
+      ...item.reason.split(',').map((value) => value.trim()).filter(Boolean),
+    ]);
+    byPath.set(key, {
+      ...existing,
+      priority: Math.min(existing.priority, item.priority),
+      required: existing.required || item.required,
+      reason: [...reasons].sort().join(','),
+    });
+  }
+  return [...byPath.values()]
+    .sort((left, right) => (
+      left.priority - right.priority
+      || left.stage.localeCompare(right.stage)
+      || left.kind.localeCompare(right.kind)
+      || left.path.localeCompare(right.path)
+    ))
+    .slice(0, MAX_MANIFEST_ROWS);
+}
+
+export async function writeContextManifest(path, rows) {
+  const text = stableRows(rows).map((item) => JSON.stringify(item)).join('\n');
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${text}\n`);
+}
+
+export async function readContextManifest(path, options = {}) {
+  if (!existsSync(path)) {
+    return { status: 'fallback', rows: [], error: null };
+  }
+  try {
+    const text = await readFile(path, 'utf8');
+    const cwd = resolve(options.cwd || process.cwd());
+    const rows = text.trim()
+      ? text.trim().split('\n').map((line) => JSON.parse(line))
+      : [];
+    if (rows.length === 0) {
+      return { status: 'invalid', rows: [], error: 'empty_manifest' };
+    }
+    const valid = rows.every((item) => (
+      item
+      && item.schema_version === CONTEXT_MANIFEST_SCHEMA_VERSION
+      && typeof item.path === 'string'
+      && item.path.length > 0
+      && typeof item.kind === 'string'
+      && item.kind.length > 0
+      && typeof item.stage === 'string'
+      && item.stage.length > 0
+      && typeof item.reason === 'string'
+      && item.reason.length > 0
+      && typeof item.priority === 'number'
+      && Number.isFinite(item.priority)
+      && typeof item.required === 'boolean'
+      && typeof item.exists === 'boolean'
+    ));
+    if (!valid) {
+      return { status: 'invalid', rows: [], error: 'invalid_manifest_row' };
+    }
+    const missingRequired = rows.find((item) => item.required && (!item.exists || !existsSync(resolve(cwd, item.path))));
+    if (missingRequired) {
+      return { status: 'invalid', rows, error: `missing_required_context:${missingRequired.kind}` };
+    }
+    return { status: 'hit', rows, error: null };
+  } catch (error) {
+    return { status: 'invalid', rows: [], error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export function buildContextManifestPath(root) {
+  return join(root, 'build-context.jsonl');
+}
+
+export function reviewContextManifestPath(root) {
+  return join(root, 'review-context.jsonl');
+}
+
+export async function generateBuildContextManifest({ cwd, root, state, slug }) {
+  const contextPaths = resolveWorkspaceContextPaths(cwd);
+  const contextSetup = await inspectWorkspaceContext(cwd);
+  const reviewReworkPath = state.review_rework_artifact_path || join(root, 'review-report.md');
+  const requiresReviewRework = state.last_confirmed_transition === 'review->build'
+    || (state.current_stage === 'review' && state.rollback_target === 'build');
+  const rows = [
+    row(cwd, { stage: 'build', kind: 'spec', path: join(root, 'spec.md'), reason: 'clarified_requirements', priority: 10 }),
+    row(cwd, { stage: 'build', kind: 'plan', path: join(root, 'plan.md'), reason: 'implementation_strategy', priority: 20 }),
+    row(cwd, { stage: 'build', kind: 'architecture', path: join(root, 'architecture.md'), reason: 'architecture_constraints', priority: 21 }),
+    row(cwd, { stage: 'build', kind: 'development-plan', path: join(root, 'development-plan.md'), reason: 'execution_steps', priority: 22 }),
+    row(cwd, { stage: 'build', kind: 'test-plan', path: join(root, 'test-plan.md'), reason: 'verification_strategy', priority: 23 }),
+    row(cwd, { stage: 'build', kind: 'prd', path: state.plan_artifact_path || join(cwd, '.loopx', 'plans', `prd-${slug}.md`), reason: 'requirements', priority: 30 }),
+    row(cwd, { stage: 'build', kind: 'test-spec', path: state.test_spec_artifact_path || join(cwd, '.loopx', 'plans', `test-spec-${slug}.md`), reason: 'test_requirements', priority: 31 }),
+    row(cwd, { stage: 'build', kind: 'vertical-slices', path: state.change_artifact_paths?.slices || join(cwd, '.loopx', 'changes', 'active', state.change_id || `chg-${slug}`, 'slices.json'), reason: 'end_to_end_delivery_slices', priority: 32 }),
+    row(cwd, { stage: 'build', kind: 'review-rework', path: reviewReworkPath, reason: 'review_requested_implementation_fixes', priority: 33, required: requiresReviewRework }),
+    row(cwd, { stage: 'build', kind: 'domain-context', path: contextPaths.domainGlossary, reason: 'domain_vocabulary', priority: 34, required: contextSetup.status !== 'missing' }),
+    row(cwd, { stage: 'build', kind: 'agent-domain', path: contextPaths.agentDomain, reason: 'agent_context_rules', priority: 35, required: false }),
+  ];
+  const manifestPath = buildContextManifestPath(root);
+  await writeContextManifest(manifestPath, rows);
+  return { path: manifestPath, rows: stableRows(rows) };
+}
+
+export async function generateReviewContextManifest({ cwd, root, state, slug }) {
+  const contextPaths = resolveWorkspaceContextPaths(cwd);
+  const contextSetup = await inspectWorkspaceContext(cwd);
+  const rows = [
+    row(cwd, { stage: 'review', kind: 'execution-record', path: join(root, 'execution-record.md'), reason: 'execution_evidence', priority: 10 }),
+    row(cwd, { stage: 'review', kind: 'test-spec', path: state.test_spec_artifact_path || join(cwd, '.loopx', 'plans', `test-spec-${slug}.md`), reason: 'acceptance_tests', priority: 20 }),
+    row(cwd, { stage: 'review', kind: 'prd', path: state.plan_artifact_path || join(cwd, '.loopx', 'plans', `prd-${slug}.md`), reason: 'requirements', priority: 21 }),
+    row(cwd, { stage: 'review', kind: 'vertical-slices', path: state.change_artifact_paths?.slices || join(cwd, '.loopx', 'changes', 'active', state.change_id || `chg-${slug}`, 'slices.json'), reason: 'slice_verification_contract', priority: 22 }),
+    row(cwd, { stage: 'review', kind: 'domain-context', path: contextPaths.domainGlossary, reason: 'terminology_and_boundary_review', priority: 23, required: contextSetup.status !== 'missing' }),
+    row(cwd, { stage: 'review', kind: 'changed-files', path: join(root, 'review-support', 'changed-files.json'), reason: 'changed_file_evidence', priority: 25, required: false }),
+    row(cwd, { stage: 'review', kind: 'residual-risks', path: join(root, 'execution-record.md'), reason: 'residual_risk_reference', priority: 26, required: false }),
+    row(cwd, { stage: 'review', kind: 'build-support', path: join(root, 'build-support'), reason: 'build_gate_evidence', priority: 30, required: false }),
+    row(cwd, { stage: 'review', kind: 'agent-domain', path: contextPaths.agentDomain, reason: 'agent_context_rules', priority: 31, required: false }),
+    row(cwd, { stage: 'review', kind: 'state', path: join(root, 'state.json'), reason: 'workflow_state', priority: 40 }),
+  ];
+  const manifestPath = reviewContextManifestPath(root);
+  await writeContextManifest(manifestPath, rows);
+  return { path: manifestPath, rows: stableRows(rows) };
+}
+
+export function manifestRowsToInputManifest(rows, fallback = []) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    return fallback;
+  }
+  return rows.map((item) => `${item.kind}:${item.path}:${item.reason}`);
+}