@ai-content-space/loopx 0.1.0 → 0.1.2

package/src/autopilot-runtime.mjs

@@ -0,0 +1,152 @@
+import { join } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+
+import { runCodexExecJson } from './codex-exec-runtime.mjs';
+
+export const AUTOPILOT_PHASES = ['expansion', 'planning', 'execution', 'qa', 'validation'];
+
+function phaseResult(phase, status, details = {}) {
+  return {
+    phase,
+    status,
+    ...details,
+  };
+}
+
+function normalizeStatus(value, fallback = 'complete') {
+  const normalized = String(value ?? fallback).trim().toLowerCase();
+  if (['complete', 'blocked', 'failed', 'skipped'].includes(normalized)) {
+    return normalized;
+  }
+  return fallback;
+}
+
+function scriptedEntry(script, phase) {
+  if (!script || typeof script !== 'object') {
+    return {};
+  }
+  return script[phase] || {};
+}
+
+export function createDefaultAutopilotAdapter() {
+  return createRealAutopilotAdapter();
+}
+
+export function createRealAutopilotAdapter({ model } = {}) {
+  return {
+    async expansion({ state }) {
+      if (state.unresolved_ambiguity_count === 0) {
+        return phaseResult('expansion', 'complete', {
+          source: state.spec_artifact_path ? 'workflow-spec' : 'generated-spec',
+          summary: 'Autopilot reused the existing loopx spec input.',
+        });
+      }
+
+      const outputPath = join(state.root || state.cwd || '.', 'autopilot', `${state.slug}-expansion.json`);
+      await mkdir(join(state.root || state.cwd || '.', 'autopilot'), { recursive: true });
+      const prompt = [
+        `You are acting as the real loopx autopilot expansion phase for workflow "${state.slug}".`,
+        'Read the current spec.md template and rewrite it into a resolved loopx spec for this workflow.',
+        'Also return only raw JSON with this shape:',
+        '{',
+        '  "status": "complete" | "blocked",',
+        '  "summary": string',
+        '}',
+        'Required spec frontmatter updates:',
+        '- unresolved_ambiguity_count: 0',
+        '- current_round: at least 1',
+        '- ambiguity_score: <= target threshold',
+        '- non_goals_resolved: true',
+        '- decision_boundaries_resolved: true',
+        '- pressure_pass_complete: true',
+        'Do not ask questions. Return JSON only, no markdown.',
+      ].join('\n');
+      const report = await runCodexExecJson({
+        cwd: state.cwd || process.cwd(),
+        prompt,
+        outputPath,
+        model,
+      });
+      return phaseResult('expansion', report.status, {
+        source: 'codex-exec',
+        summary: report.summary,
+      });
+    },
+    async planning({ planResult }) {
+      return phaseResult(
+        'planning',
+        planResult.state.plan_critic_verdict === 'approve' ? 'complete' : 'blocked',
+        {
+          planIteration: planResult.state.plan_current_iteration,
+          criticVerdict: planResult.state.plan_critic_verdict,
+        },
+      );
+    },
+    async execution({ buildResult }) {
+      return phaseResult(
+        'execution',
+        Array.isArray(buildResult.state.build_blockers) && buildResult.state.build_blockers.some((item) => item.startsWith('lane_incomplete_'))
+          ? 'blocked'
+          : 'complete',
+        {
+          buildIteration: buildResult.state.build_current_iteration,
+          laneCount: Array.isArray(buildResult.state.build_lane_statuses) ? buildResult.state.build_lane_statuses.length : 0,
+        },
+      );
+    },
+    async qa({ buildResult }) {
+      const ok = buildResult.state.build_verification_status === 'complete'
+        && buildResult.state.build_architect_verification_status === 'approve'
+        && ['complete', 'skipped'].includes(buildResult.state.build_deslop_status)
+        && ['complete', 'skipped'].includes(buildResult.state.build_regression_status)
+        && buildResult.state.execution_record_status === 'complete';
+      return phaseResult('qa', ok ? 'complete' : 'blocked', {
+        verificationStatus: buildResult.state.build_verification_status,
+        architectStatus: buildResult.state.build_architect_verification_status,
+        deslopStatus: buildResult.state.build_deslop_status,
+        regressionStatus: buildResult.state.build_regression_status,
+      });
+    },
+    async validation({ reviewResult }) {
+      return phaseResult(
+        'validation',
+        reviewResult.verdict === 'APPROVE' ? 'complete' : 'blocked',
+        {
+          reviewVerdict: reviewResult.verdict,
+          rollbackTarget: reviewResult.rollbackTarget,
+        },
+      );
+    },
+  };
+}
+
+export function createScriptedAutopilotAdapter(script = {}) {
+  const defaults = createDefaultAutopilotAdapter();
+  return {
+    async expansion(context) {
+      const base = await defaults.expansion(context);
+      const override = scriptedEntry(script, 'expansion');
+      return { ...base, ...override, status: normalizeStatus(override.status, base.status) };
+    },
+    async planning(context) {
+      const base = await defaults.planning(context);
+      const override = scriptedEntry(script, 'planning');
+      return { ...base, ...override, status: normalizeStatus(override.status, base.status) };
+    },
+    async execution(context) {
+      const base = await defaults.execution(context);
+      const override = scriptedEntry(script, 'execution');
+      return { ...base, ...override, status: normalizeStatus(override.status, base.status) };
+    },
+    async qa(context) {
+      const base = await defaults.qa(context);
+      const override = scriptedEntry(script, 'qa');
+      return { ...base, ...override, status: normalizeStatus(override.status, base.status) };
+    },
+    async validation(context) {
+      const base = await defaults.validation(context);
+      const override = scriptedEntry(script, 'validation');
+      return { ...base, ...override, status: normalizeStatus(override.status, base.status) };
+    },
+  };
+}

package/src/build-runtime.mjs

@@ -0,0 +1,146 @@
+import { join } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+
+import { runCodexExecJson } from './codex-exec-runtime.mjs';
+
+const DEFAULT_BUILD_MAX_ITERATIONS = 10;
+const DEFAULT_BUILD_LANES = ['execution', 'evidence', 'verification'];
+
+function defaultLaneResult(name, iteration) {
+  return {
+    name,
+    status: 'complete',
+    summary: `${name} lane completed in iteration ${iteration}.`,
+    evidence: [
+      {
+        id: `${name}-${iteration}`,
+        kind: 'artifact',
+        summary: `${name} lane evidence`,
+        ref: `${name}-lane-${iteration}.md`,
+      },
+    ],
+  };
+}
+
+function scriptedValue(value, index, fallback) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return fallback;
+  }
+  return value[Math.min(index, value.length - 1)];
+}
+
+function normalizeVerdict(raw, fallback = 'approve') {
+  const value = String(raw ?? fallback).trim().toLowerCase();
+  if (['approve', 'reject', 'iterate'].includes(value)) {
+    return value;
+  }
+  return fallback;
+}
+
+function normalizeStatus(raw, fallback = 'complete') {
+  const value = String(raw ?? fallback).trim().toLowerCase();
+  if (['complete', 'failed', 'pending', 'skipped'].includes(value)) {
+    return value;
+  }
+  return fallback;
+}
+
+function buildIterationData({ slug, iteration, noDeslop = false }, scriptEntry = {}) {
+  const laneNames = Array.isArray(scriptEntry.lanes) && scriptEntry.lanes.length > 0
+    ? scriptEntry.lanes.map((lane) => lane.name)
+    : DEFAULT_BUILD_LANES;
+  const lanes = laneNames.map((name) => {
+    const scriptedLane = Array.isArray(scriptEntry.lanes)
+      ? scriptEntry.lanes.find((lane) => lane.name === name)
+      : null;
+    return {
+      ...defaultLaneResult(name, iteration),
+      ...(scriptedLane || {}),
+      status: normalizeStatus(scriptedLane?.status, 'complete'),
+    };
+  });
+  const verificationStatus = normalizeStatus(scriptEntry.verificationStatus, 'complete');
+  const architectVerdict = normalizeVerdict(scriptEntry.architectVerdict, 'approve');
+  const deslopStatus = noDeslop ? 'skipped' : normalizeStatus(scriptEntry.deslopStatus, 'complete');
+  const regressionStatus = noDeslop ? 'skipped' : normalizeStatus(scriptEntry.regressionStatus, 'complete');
+
+  return {
+    slug,
+    iteration,
+    runId: `${slug}-build-run-${iteration}`,
+    actorId: `${slug}-builder-1`,
+    lanes,
+    verificationStatus,
+    architectVerdict,
+    deslopStatus,
+    regressionStatus,
+    executionEvidence: [
+      `lane_count=${lanes.length}`,
+      ...lanes.map((lane) => `${lane.name}:${lane.status}`),
+    ],
+    verificationEvidence: scriptEntry.verificationEvidence || [
+      `verification=${verificationStatus}`,
+      `architect=${architectVerdict}`,
+      `deslop=${deslopStatus}`,
+      `regression=${regressionStatus}`,
+    ],
+    architectFindings: scriptEntry.architectFindings || (
+      architectVerdict === 'approve'
+        ? ['Architect gate approved the build iteration.']
+        : ['Architect gate rejected the build iteration.']
+    ),
+    limitations: scriptEntry.limitations || (architectVerdict === 'approve' ? ['none'] : ['Architect review did not approve this iteration.']),
+  };
+}
+
+export function createDefaultBuildAdapter() {
+  return createRealBuildAdapter();
+}
+
+export function createRealBuildAdapter({ model } = {}) {
+  return {
+    maxIterations: DEFAULT_BUILD_MAX_ITERATIONS,
+    async executeLanes(context) {
+      const outputPath = join(context.root || context.cwd, 'build-support', `runtime-build-iteration-${context.iteration}.json`);
+      await mkdir(join(context.root || context.cwd, 'build-support'), { recursive: true });
+      const prompt = [
+        `You are acting as the real loopx build runtime for workflow "${context.slug}".`,
+        'Execute the approved build work in this repository and return only raw JSON with this shape:',
+        '{',
+        '  "lanes": [{"name": string, "status": "complete" | "failed" | "pending" | "skipped", "summary": string, "evidence": [{"id": string, "kind": string, "summary": string, "ref": string}]}],',
+        '  "verificationStatus": "complete" | "failed" | "pending" | "skipped",',
+        '  "architectVerdict": "approve" | "reject" | "iterate",',
+        '  "deslopStatus": "complete" | "failed" | "pending" | "skipped",',
+        '  "regressionStatus": "complete" | "failed" | "pending" | "skipped",',
+        '  "executionEvidence": string[],',
+        '  "verificationEvidence": string[],',
+        '  "architectFindings": string[],',
+        '  "limitations": string[]',
+        '}',
+        `noDeslop: ${Boolean(context.noDeslop)}`,
+        `planArtifactPath: ${context.planArtifactPath}`,
+        `testSpecArtifactPath: ${context.testSpecArtifactPath}`,
+        'Do not ask questions. Real code edits are allowed. Keep execution-record.md as the sole canonical execution artifact; return JSON only, no markdown.',
+      ].join('\n');
+      const report = await runCodexExecJson({
+        cwd: context.cwd,
+        prompt,
+        outputPath,
+        model,
+      });
+      return buildIterationData(context, report);
+    },
+  };
+}
+
+export function createScriptedBuildAdapter(script = {}) {
+  return {
+    maxIterations: script.maxIterations || DEFAULT_BUILD_MAX_ITERATIONS,
+    async executeLanes(context) {
+      const entry = scriptedValue(script.iterations, context.iteration - 1, {});
+      return buildIterationData(context, entry || {});
+    },
+  };
+}
+
+export { DEFAULT_BUILD_MAX_ITERATIONS };

package/src/cli.mjs

@@ -2,16 +2,17 @@
 
 import { autopilotStage, approveStage, buildStage, clarifyStage, initWorkspace, planStage, reviewStage, statusSummary } from './workflow.mjs';
 import { installBundledSkills } from './install-discovery.mjs';
+import { withNextSkill } from './next-skill.mjs';
 import { doctorRuntime, migrateLegacyRuntime } from './runtime-maintenance.mjs';
 
 function usage() {
   return [
     'Usage:',
     '  loopx init [--slug <slug>]',
-    '  loopx clarify <slug>',
+    '  loopx clarify <slug> [--standard|--deep]',
     '  loopx approve <slug> --from <stage> --to <stage>',
-    '  loopx plan <slug>',
-    '  loopx build <slug>',
+    '  loopx plan [slug] [--direct <spec-path>] [--interactive] [--deliberate]',
+    '  loopx build <slug> [--no-deslop]',
     '  loopx review <slug> [--reviewer <name>]',
     '  loopx autopilot <slug> [--reviewer <name>]',
     '  loopx status [slug] [--json]',
@@ -46,7 +47,7 @@ function parseArgs(argv) {
 
 function printHumanStatus(status) {
   if (!status.initialized) {
-    console.log('LoopX workspace is not initialized.');
+    console.log('loopx workspace is not initialized.');
     console.log(status.next_action);
     return;
   }
@@ -65,6 +66,35 @@ function printHumanStatus(status) {
   console.log(`contract: ${status.contract}`);
   console.log(`schema_version: ${status.schema_version}`);
   console.log(`stage: ${status.state?.current_stage ?? '(none)'}`);
+  if (status.state?.current_stage === 'clarify') {
+    console.log(`clarify_round: ${status.state.clarify_current_round}/${status.state.clarify_max_rounds}`);
+    console.log(`clarify_ambiguity_score: ${status.state.clarify_ambiguity_score}`);
+    console.log(`clarify_target_ambiguity_threshold: ${status.state.clarify_target_ambiguity_threshold}`);
+    console.log(`clarify_gates: non_goals=${status.state.clarify_non_goals_resolved} decision_boundaries=${status.state.clarify_decision_boundaries_resolved} pressure_pass=${status.state.clarify_pressure_pass_complete}`);
+  }
+  if (status.state?.current_stage === 'plan') {
+    console.log(`plan_iteration: ${status.state.plan_current_iteration}/${status.state.plan_max_iterations}`);
+    console.log(`plan_consensus_mode: ${status.state.plan_consensus_mode}`);
+    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_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') {
+    console.log(`build_iteration: ${status.state.build_current_iteration}/${status.state.build_max_iterations}`);
+    console.log(`build_parallel_mode: ${status.state.build_parallel_mode}`);
+    console.log(`build_verification_status: ${status.state.build_verification_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(`build_blockers: ${Array.isArray(status.state.build_blockers) && status.state.build_blockers.length > 0 ? status.state.build_blockers.join(', ') : '(none)'}`);
+  }
+  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}`);
+    console.log(`autopilot_blockers: ${Array.isArray(status.state.autopilot_blockers) && status.state.autopilot_blockers.length > 0 ? status.state.autopilot_blockers.join(', ') : '(none)'}`);
+  }
   console.log(`requested_transition: ${status.state?.requested_transition ?? 'none'}`);
   console.log(`last_confirmed_transition: ${status.state?.last_confirmed_transition ?? 'none'}`);
   console.log(`pending_user_decision: ${status.state?.pending_user_decision ?? 'none'}`);
@@ -87,8 +117,9 @@ async function main() {
         return;
       }
       case 'clarify': {
-        const result = await clarifyStage(process.cwd(), positionals[0]);
-        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state }, null, 2));
+        const profile = options.get('--deep') ? 'deep' : 'standard';
+        const result = await clarifyStage(process.cwd(), positionals[0], { profile });
+        console.log(JSON.stringify(withNextSkill({ ok: true, command, root: result.root, state: result.state }, result.state), null, 2));
         return;
       }
       case 'approve': {
@@ -96,24 +127,30 @@ 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': {
-        const result = await planStage(process.cwd(), positionals[0]);
-        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state }, null, 2));
+        const result = await planStage(process.cwd(), positionals[0], {
+          directSpecPath: options.get('--direct'),
+          interactive: Boolean(options.get('--interactive')),
+          deliberate: Boolean(options.get('--deliberate')),
+        });
+        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]);
-        console.log(JSON.stringify({ ok: true, command, root: result.root, state: result.state }, null, 2));
+        const result = await buildStage(process.cwd(), positionals[0], {
+          noDeslop: Boolean(options.get('--no-deslop')),
+        });
+        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 }, result.state), null, 2));
         return;
       }
       case 'autopilot': {

package/src/codex-exec-runtime.mjs

@@ -0,0 +1,97 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+const DEFAULT_CODEX_MODEL = 'gpt-5.4';
+const DEFAULT_CODEX_TIMEOUT_MS = 120000;
+const DEFAULT_CODEX_REASONING = 'low';
+
+function codexBinary() {
+  return process.env.LOOPX_CODEX_BIN || 'codex';
+}
+
+export async function readJsonArtifact(path) {
+  const text = await readFile(path, 'utf8');
+  return JSON.parse(text);
+}
+
+export async function runCodexExec({
+  cwd,
+  prompt,
+  outputPath,
+  model = DEFAULT_CODEX_MODEL,
+  extraArgs = [],
+  timeoutMs = DEFAULT_CODEX_TIMEOUT_MS,
+  reasoningEffort = DEFAULT_CODEX_REASONING,
+}) {
+  const args = [
+    'exec',
+    '--dangerously-bypass-approvals-and-sandbox',
+    '-C',
+    cwd,
+    '-m',
+    model,
+    '-c',
+    `model_reasoning_effort=\"${reasoningEffort}\"`,
+    '-o',
+    outputPath,
+    ...extraArgs,
+    prompt,
+  ];
+
+  const child = spawn(codexBinary(), args, {
+    cwd,
+    env: {
+      ...process.env,
+      CODEX_DISABLE_UPDATE: '1',
+    },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  child.stdin.end();
+
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  child.stdout.on('data', (chunk) => stdoutChunks.push(Buffer.from(chunk)));
+  child.stderr.on('data', (chunk) => stderrChunks.push(Buffer.from(chunk)));
+
+  const timeout = setTimeout(() => {
+    child.kill('SIGTERM');
+  }, timeoutMs);
+
+  try {
+    const exitCode = await new Promise((resolve, reject) => {
+      child.on('error', reject);
+      child.on('close', resolve);
+    });
+    clearTimeout(timeout);
+    const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+    const stderr = Buffer.concat(stderrChunks).toString('utf8');
+    const finalMessage = existsSync(outputPath) ? await readFile(outputPath, 'utf8') : '';
+    if (exitCode !== 0) {
+      throw new Error(`exit_${exitCode}`);
+    }
+    return {
+      ok: true,
+      finalMessage,
+      stdout,
+      stderr,
+    };
+  } catch (error) {
+    clearTimeout(timeout);
+    const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+    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}`);
+  }
+}
+
+export async function runCodexExecJson(options) {
+  const result = await runCodexExec(options);
+  const text = result.finalMessage.trim();
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`codex_exec_invalid_json:${error instanceof Error ? error.message : String(error)}\nbody:${text}`);
+  }
+}

package/src/install-discovery.mjs

@@ -7,11 +7,11 @@ import { fileURLToPath } from 'node:url';
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = resolve(MODULE_DIR, '..');
 const LOOPX_SKILLS = [
-  'loopx-clarify',
-  'loopx-plan',
-  'loopx-build',
-  'loopx-review',
-  'loopx-autopilot',
+  'clarify',
+  'plan',
+  'build',
+  'review',
+  'autopilot',
 ];
 const LOOPX_INSTALLATION_IDENTITY = 'loopx';
 
@@ -150,7 +150,7 @@ async function materializeSkill(skillName, env = process.env, options = {}) {
 
 function buildRegistryRow(record, env = process.env, options = {}) {
   return {
-    source: 'LoopX',
+    source: 'loopx',
     sourceType: 'local',
     installationIdentity: options.installationIdentity,
     distributionChannel: options.distributionChannel,
@@ -173,7 +173,7 @@ function buildRegistryRow(record, env = process.env, options = {}) {
 function isLoopxOwnedIdentity(skillName, row, env = process.env) {
   return Boolean(
     row
-      && row.source === 'LoopX'
+      && row.source === 'loopx'
       && row.sourceType === 'local'
       && (
         row.installationIdentity === LOOPX_INSTALLATION_IDENTITY

package/src/next-skill.mjs

@@ -0,0 +1,33 @@
+export function nextSkillCommand(state) {
+  if (!state || state.stage_status !== 'awaiting-approval' || !state.slug) {
+    return null;
+  }
+  if (state.current_stage === 'clarify') {
+    return `$plan ${state.slug}`;
+  }
+  if (state.current_stage === 'plan' && Array.isArray(state.plan_blockers) && state.plan_blockers.length === 0) {
+    return `$build ${state.slug}`;
+  }
+  if (state.current_stage === 'build' && Array.isArray(state.build_blockers) && state.build_blockers.length === 0) {
+    return `$review ${state.slug}`;
+  }
+  return null;
+}
+
+export function nextSkillHint(state) {
+  const command = nextSkillCommand(state);
+  if (!command) {
+    return null;
+  }
+  return `Next: ${command}`;
+}
+
+export function withNextSkill(payload, state) {
+  const nextCommand = nextSkillCommand(state);
+  const nextHint = nextSkillHint(state);
+  return {
+    ...payload,
+    next_skill_command: nextCommand,
+    next_skill_hint: nextHint,
+  };
+}