aw-ecc 1.4.21

package/scripts/orchestrate-codex-worker.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -ne 3 ]]; then
+  echo "Usage: bash scripts/orchestrate-codex-worker.sh <task-file> <handoff-file> <status-file>" >&2
+  exit 1
+fi
+
+task_file="$1"
+handoff_file="$2"
+status_file="$3"
+
+timestamp() {
+  date -u +"%Y-%m-%dT%H:%M:%SZ"
+}
+
+write_status() {
+  local state="$1"
+  local details="$2"
+
+  cat > "$status_file" <<EOF
+# Status
+
+- State: $state
+- Updated: $(timestamp)
+- Branch: $(git rev-parse --abbrev-ref HEAD)
+- Worktree: \`$(pwd)\`
+
+$details
+EOF
+}
+
+mkdir -p "$(dirname "$handoff_file")" "$(dirname "$status_file")"
+
+if [[ ! -r "$task_file" ]]; then
+  write_status "failed" "- Error: task file is missing or unreadable (\`$task_file\`)"
+  {
+    echo "# Handoff"
+    echo
+    echo "- Failed: $(timestamp)"
+    echo "- Branch: \`$(git rev-parse --abbrev-ref HEAD)\`"
+    echo "- Worktree: \`$(pwd)\`"
+    echo
+    echo "Task file is missing or unreadable: \`$task_file\`"
+  } > "$handoff_file"
+  exit 1
+fi
+
+write_status "running" "- Task file: \`$task_file\`"
+
+prompt_file="$(mktemp)"
+output_file="$(mktemp)"
+cleanup() {
+  rm -f "$prompt_file" "$output_file"
+}
+trap cleanup EXIT
+
+cat > "$prompt_file" <<EOF
+You are one worker in an ECC tmux/worktree swarm.
+
+Rules:
+- Work only in the current git worktree.
+- Do not touch sibling worktrees or the parent repo checkout.
+- Complete the task from the task file below.
+- Do not spawn subagents or external agents for this task.
+- Report progress and final results in stdout only.
+- Do not write handoff or status files yourself; the launcher manages those artifacts.
+- If you change code or docs, keep the scope narrow and defensible.
+- In your final response, include exactly these sections:
+  1. Summary
+  2. Files Changed
+  3. Validation
+  4. Remaining Risks
+
+Task file: $task_file
+
+$(cat "$task_file")
+EOF
+
+if codex exec -p yolo -m gpt-5.4 --color never -C "$(pwd)" -o "$output_file" - < "$prompt_file"; then
+  {
+    echo "# Handoff"
+    echo
+    echo "- Completed: $(timestamp)"
+    echo "- Branch: \`$(git rev-parse --abbrev-ref HEAD)\`"
+    echo "- Worktree: \`$(pwd)\`"
+    echo
+    cat "$output_file"
+    echo
+    echo "## Git Status"
+    echo
+    git status --short
+  } > "$handoff_file"
+  write_status "completed" "- Handoff file: \`$handoff_file\`"
+else
+  {
+    echo "# Handoff"
+    echo
+    echo "- Failed: $(timestamp)"
+    echo "- Branch: \`$(git rev-parse --abbrev-ref HEAD)\`"
+    echo "- Worktree: \`$(pwd)\`"
+    echo
+    echo "The Codex worker exited with a non-zero status."
+  } > "$handoff_file"
+  write_status "failed" "- Handoff file: \`$handoff_file\`"
+  exit 1
+fi

package/scripts/orchestrate-worktrees.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  buildOrchestrationPlan,
+  executePlan,
+} = require('./lib/tmux-worktree-orchestrator');
+
+function usage() {
+  console.error('Usage: node scripts/orchestrate-worktrees.js <plan.json> [--execute]');
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const execute = args.includes('--execute');
+  const target = args.find((arg) => !arg.startsWith('--'));
+
+  if (!target) {
+    usage();
+    process.exit(1);
+  }
+
+  const planPath = path.resolve(process.cwd(), target);
+  const planConfig = JSON.parse(fs.readFileSync(planPath, 'utf8'));
+  const plan = buildOrchestrationPlan({
+    ...planConfig,
+    repoRoot: planConfig.repoRoot || process.cwd(),
+  });
+
+  if (execute) {
+    executePlan(plan);
+  }
+
+  process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+}
+
+main();

package/scripts/orchestration-status.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { slugify } = require('./lib/tmux-worktree-orchestrator');
+
+function usage() {
+  console.error('Usage: node scripts/orchestration-status.js <plan.json|session-name>');
+}
+
+function buildPlanSnapshot(planPath, planConfig) {
+  const repoRoot = path.resolve(planConfig.repoRoot || path.dirname(planPath));
+  const sessionId = slugify(planConfig.sessionName || path.basename(planPath, path.extname(planPath)));
+
+  return {
+    schemaVersion: 'ecc.session.v1',
+    adapterId: 'dmux-tmux',
+    session: {
+      id: sessionId,
+      kind: 'orchestrated',
+      state: 'planned',
+      repoRoot,
+      sourceTarget: {
+        type: 'plan',
+        value: planPath,
+      },
+    },
+    workers: [],
+    aggregates: {
+      workerCount: 0,
+      states: {},
+      healths: {},
+    },
+  };
+}
+
+function buildSessionSnapshot(sessionName) {
+  return {
+    schemaVersion: 'ecc.session.v1',
+    adapterId: 'dmux-tmux',
+    session: {
+      id: slugify(sessionName),
+      kind: 'orchestrated',
+      state: 'unknown',
+      repoRoot: null,
+      sourceTarget: {
+        type: 'session',
+        value: sessionName,
+      },
+    },
+    workers: [],
+    aggregates: {
+      workerCount: 0,
+      states: {},
+      healths: {},
+    },
+  };
+}
+
+function main() {
+  const target = process.argv[2];
+  if (!target) {
+    usage();
+    process.exit(1);
+  }
+
+  const resolvedTarget = path.resolve(process.cwd(), target);
+  let snapshot;
+
+  if (fs.existsSync(resolvedTarget) && fs.statSync(resolvedTarget).isFile()) {
+    const planConfig = JSON.parse(fs.readFileSync(resolvedTarget, 'utf8'));
+    snapshot = buildPlanSnapshot(resolvedTarget, planConfig);
+  } else {
+    snapshot = buildSessionSnapshot(target);
+  }
+
+  process.stdout.write(`${JSON.stringify(snapshot, null, 2)}\n`);
+}
+
+main();

package/scripts/repair.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+const { repairInstalledStates } = require('./lib/install-lifecycle');
+const { SUPPORTED_INSTALL_TARGETS } = require('./lib/install-manifests');
+
+function showHelp(exitCode = 0) {
+  console.log(`
+Usage: node scripts/repair.js [--target <${SUPPORTED_INSTALL_TARGETS.join('|')}>] [--dry-run] [--json]
+
+Rebuild ECC-managed files recorded in install-state for the current context.
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const parsed = {
+    targets: [],
+    dryRun: false,
+    json: false,
+    help: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--target') {
+      parsed.targets.push(args[index + 1] || null);
+      index += 1;
+    } else if (arg === '--dry-run') {
+      parsed.dryRun = true;
+    } else if (arg === '--json') {
+      parsed.json = true;
+    } else if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function printHuman(result) {
+  if (result.results.length === 0) {
+    console.log('No ECC install-state files found for the current home/project context.');
+    return;
+  }
+
+  console.log('Repair summary:\n');
+  for (const entry of result.results) {
+    console.log(`- ${entry.adapter.id}`);
+    console.log(`  Status: ${entry.status.toUpperCase()}`);
+    console.log(`  Install-state: ${entry.installStatePath}`);
+
+    if (entry.error) {
+      console.log(`  Error: ${entry.error}`);
+      continue;
+    }
+
+    const paths = result.dryRun ? entry.plannedRepairs : entry.repairedPaths;
+    console.log(`  ${result.dryRun ? 'Planned repairs' : 'Repaired paths'}: ${paths.length}`);
+  }
+
+  console.log(`\nSummary: checked=${result.summary.checkedCount}, ${result.dryRun ? 'planned' : 'repaired'}=${result.dryRun ? result.summary.plannedRepairCount : result.summary.repairedCount}, errors=${result.summary.errorCount}`);
+}
+
+function main() {
+  try {
+    const options = parseArgs(process.argv);
+    if (options.help) {
+      showHelp(0);
+    }
+
+    const result = repairInstalledStates({
+      repoRoot: require('path').join(__dirname, '..'),
+      homeDir: process.env.HOME,
+      projectRoot: process.cwd(),
+      targets: options.targets,
+      dryRun: options.dryRun,
+    });
+    const hasErrors = result.summary.errorCount > 0;
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printHuman(result);
+    }
+
+    process.exitCode = hasErrors ? 1 : 0;
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/session-inspect.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { createAdapterRegistry, inspectSessionTarget } = require('./lib/session-adapters/registry');
+const { readSkillObservations } = require('./lib/skill-improvement/observations');
+const { buildSkillHealthReport } = require('./lib/skill-improvement/health');
+const { proposeSkillAmendment } = require('./lib/skill-improvement/amendify');
+const { buildSkillEvaluationScaffold } = require('./lib/skill-improvement/evaluate');
+
+function usage() {
+  console.log([
+    'Usage:',
+    '  node scripts/session-inspect.js <target> [--adapter <id>] [--target-type <type>] [--write <output.json>]',
+    '  node scripts/session-inspect.js --list-adapters',
+    '',
+    'Targets:',
+    '  <plan.json>          Dmux/orchestration plan file',
+    '  <session-name>       Dmux session name when the coordination directory exists',
+    '  claude:latest        Most recent Claude session history entry',
+    '  claude:<id|alias>    Specific Claude session or alias',
+    '  <session.tmp>        Direct path to a Claude session file',
+    '  skills:health        Inspect skill failure/success patterns from observations',
+    '  skills:amendify      Propose a SKILL.md patch from failure evidence',
+    '  skills:evaluate      Compare baseline vs amended skill outcomes',
+    '',
+    'Examples:',
+    '  node scripts/session-inspect.js .claude/plan/workflow.json',
+    '  node scripts/session-inspect.js workflow-visual-proof',
+    '  node scripts/session-inspect.js claude:latest',
+    '  node scripts/session-inspect.js latest --target-type claude-history',
+    '  node scripts/session-inspect.js skills:health',
+    '  node scripts/session-inspect.js skills:amendify --skill api-design',
+    '  node scripts/session-inspect.js claude:a1b2c3d4 --write /tmp/session.json'
+  ].join('\n'));
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const target = args.find(argument => !argument.startsWith('--'));
+  const listAdapters = args.includes('--list-adapters');
+
+  const adapterIndex = args.indexOf('--adapter');
+  const adapterId = adapterIndex >= 0 ? args[adapterIndex + 1] : null;
+
+  const targetTypeIndex = args.indexOf('--target-type');
+  const targetType = targetTypeIndex >= 0 ? args[targetTypeIndex + 1] : null;
+
+  const skillIndex = args.indexOf('--skill');
+  const skillId = skillIndex >= 0 ? args[skillIndex + 1] : null;
+
+  const amendmentIndex = args.indexOf('--amendment-id');
+  const amendmentId = amendmentIndex >= 0 ? args[amendmentIndex + 1] : null;
+
+  const observationsIndex = args.indexOf('--observations');
+  const observationsPath = observationsIndex >= 0 ? args[observationsIndex + 1] : null;
+
+  const writeIndex = args.indexOf('--write');
+  const writePath = writeIndex >= 0 ? args[writeIndex + 1] : null;
+
+  return { target, adapterId, targetType, writePath, listAdapters, skillId, amendmentId, observationsPath };
+}
+
+function inspectSkillLoopTarget(target, options = {}) {
+  const observations = readSkillObservations({
+    cwd: options.cwd,
+    projectRoot: options.cwd,
+    observationsPath: options.observationsPath
+  });
+
+  if (target === 'skills:health') {
+    return buildSkillHealthReport(observations, {
+      skillId: options.skillId || null
+    });
+  }
+
+  if (target === 'skills:amendify') {
+    if (!options.skillId) {
+      throw new Error('skills:amendify requires --skill <id>');
+    }
+
+    return proposeSkillAmendment(options.skillId, observations);
+  }
+
+  if (target === 'skills:evaluate') {
+    if (!options.skillId) {
+      throw new Error('skills:evaluate requires --skill <id>');
+    }
+
+    return buildSkillEvaluationScaffold(options.skillId, observations, {
+      amendmentId: options.amendmentId || null
+    });
+  }
+
+  return null;
+}
+
+function main() {
+  const { target, adapterId, targetType, writePath, listAdapters, skillId, amendmentId, observationsPath } = parseArgs(process.argv);
+
+  if (listAdapters) {
+    const registry = createAdapterRegistry();
+    console.log(JSON.stringify({ adapters: registry.listAdapters() }, null, 2));
+    return;
+  }
+
+  if (!target) {
+    usage();
+    process.exit(1);
+  }
+
+  const skillLoopPayload = inspectSkillLoopTarget(target, {
+    cwd: process.cwd(),
+    skillId,
+    amendmentId,
+    observationsPath
+  });
+  const payloadObject = skillLoopPayload || inspectSessionTarget(
+    targetType ? { type: targetType, value: target } : target,
+    {
+      cwd: process.cwd(),
+      adapterId
+    }
+  );
+  const payload = JSON.stringify(payloadObject, null, 2);
+
+  if (writePath) {
+    const absoluteWritePath = path.resolve(writePath);
+    fs.mkdirSync(path.dirname(absoluteWritePath), { recursive: true });
+    fs.writeFileSync(absoluteWritePath, payload + '\n', 'utf8');
+  }
+
+  console.log(payload);
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`[session-inspect] ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  main,
+  parseArgs
+};

package/scripts/sessions-cli.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+'use strict';
+
+const { createStateStore } = require('./lib/state-store');
+
+function showHelp(exitCode = 0) {
+  console.log(`
+Usage: node scripts/sessions-cli.js [<session-id>] [--db <path>] [--json] [--limit <n>]
+
+List recent ECC sessions from the SQLite state store or inspect a single session
+with worker, skill-run, and decision detail.
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const parsed = {
+    dbPath: null,
+    help: false,
+    json: false,
+    limit: 10,
+    sessionId: null,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--db') {
+      parsed.dbPath = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--json') {
+      parsed.json = true;
+    } else if (arg === '--limit') {
+      parsed.limit = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else if (!arg.startsWith('--') && !parsed.sessionId) {
+      parsed.sessionId = arg;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function printSessionList(payload) {
+  console.log('Recent sessions:\n');
+
+  if (payload.sessions.length === 0) {
+    console.log('No sessions found.');
+    return;
+  }
+
+  for (const session of payload.sessions) {
+    console.log(`- ${session.id} [${session.harness}/${session.adapterId}] ${session.state}`);
+    console.log(`  Repo: ${session.repoRoot || '(unknown)'}`);
+    console.log(`  Started: ${session.startedAt || '(unknown)'}`);
+    console.log(`  Ended: ${session.endedAt || '(active)'}`);
+    console.log(`  Workers: ${session.workerCount}`);
+  }
+
+  console.log(`\nTotal sessions: ${payload.totalCount}`);
+}
+
+function printWorkers(workers) {
+  console.log(`Workers: ${workers.length}`);
+  if (workers.length === 0) {
+    console.log('  - none');
+    return;
+  }
+
+  for (const worker of workers) {
+    console.log(`  - ${worker.id || worker.label || '(unknown)'} ${worker.state || 'unknown'}`);
+    console.log(`    Branch: ${worker.branch || '(unknown)'}`);
+    console.log(`    Worktree: ${worker.worktree || '(unknown)'}`);
+  }
+}
+
+function printSkillRuns(skillRuns) {
+  console.log(`Skill runs: ${skillRuns.length}`);
+  if (skillRuns.length === 0) {
+    console.log('  - none');
+    return;
+  }
+
+  for (const skillRun of skillRuns) {
+    console.log(`  - ${skillRun.id} ${skillRun.outcome} ${skillRun.skillId}@${skillRun.skillVersion}`);
+    console.log(`    Task: ${skillRun.taskDescription}`);
+    console.log(`    Duration: ${skillRun.durationMs ?? '(unknown)'} ms`);
+  }
+}
+
+function printDecisions(decisions) {
+  console.log(`Decisions: ${decisions.length}`);
+  if (decisions.length === 0) {
+    console.log('  - none');
+    return;
+  }
+
+  for (const decision of decisions) {
+    console.log(`  - ${decision.id} ${decision.status}`);
+    console.log(`    Title: ${decision.title}`);
+    console.log(`    Alternatives: ${decision.alternatives.join(', ') || '(none)'}`);
+  }
+}
+
+function printSessionDetail(payload) {
+  console.log(`Session: ${payload.session.id}`);
+  console.log(`Harness: ${payload.session.harness}`);
+  console.log(`Adapter: ${payload.session.adapterId}`);
+  console.log(`State: ${payload.session.state}`);
+  console.log(`Repo: ${payload.session.repoRoot || '(unknown)'}`);
+  console.log(`Started: ${payload.session.startedAt || '(unknown)'}`);
+  console.log(`Ended: ${payload.session.endedAt || '(active)'}`);
+  console.log();
+  printWorkers(payload.workers);
+  console.log();
+  printSkillRuns(payload.skillRuns);
+  console.log();
+  printDecisions(payload.decisions);
+}
+
+async function main() {
+  let store = null;
+
+  try {
+    const options = parseArgs(process.argv);
+    if (options.help) {
+      showHelp(0);
+    }
+
+    store = await createStateStore({
+      dbPath: options.dbPath,
+      homeDir: process.env.HOME,
+    });
+
+    if (!options.sessionId) {
+      const payload = store.listRecentSessions({ limit: options.limit });
+      if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+      } else {
+        printSessionList(payload);
+      }
+      return;
+    }
+
+    const payload = store.getSessionDetail(options.sessionId);
+    if (!payload) {
+      throw new Error(`Session not found: ${options.sessionId}`);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else {
+      printSessionDetail(payload);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  } finally {
+    if (store) {
+      store.close();
+    }
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  main,
+  parseArgs,
+};