kodelyth-ecc 1.2.0

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,108 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  buildOrchestrationPlan,
+  executePlan,
+  materializePlan
+} = require('./lib/tmux-worktree-orchestrator');
+
+function usage() {
+  console.log([
+    'Usage:',
+    '  node scripts/orchestrate-worktrees.js <plan.json> [--execute]',
+    '  node scripts/orchestrate-worktrees.js <plan.json> [--write-only]',
+    '',
+    'Placeholders supported in launcherCommand:',
+    '  {worker_name} {worker_slug} {session_name} {repo_root}',
+    '  {worktree_path} {branch_name} {task_file} {handoff_file} {status_file}',
+    '',
+    'Without flags the script prints a dry-run plan only.'
+  ].join('\n'));
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const planPath = args.find(arg => !arg.startsWith('--'));
+  return {
+    execute: args.includes('--execute'),
+    planPath,
+    writeOnly: args.includes('--write-only')
+  };
+}
+
+function loadPlanConfig(planPath) {
+  const absolutePath = path.resolve(planPath);
+  const raw = fs.readFileSync(absolutePath, 'utf8');
+  const config = JSON.parse(raw);
+  config.repoRoot = config.repoRoot || process.cwd();
+  return { absolutePath, config };
+}
+
+function printDryRun(plan, absolutePath) {
+  const preview = {
+    planFile: absolutePath,
+    sessionName: plan.sessionName,
+    repoRoot: plan.repoRoot,
+    coordinationDir: plan.coordinationDir,
+    workers: plan.workerPlans.map(worker => ({
+      workerName: worker.workerName,
+      branchName: worker.branchName,
+      worktreePath: worker.worktreePath,
+      seedPaths: worker.seedPaths,
+      taskFilePath: worker.taskFilePath,
+      handoffFilePath: worker.handoffFilePath,
+      launchCommand: worker.launchCommand
+    })),
+    commands: [
+      ...plan.workerPlans.map(worker => worker.gitCommand),
+      ...plan.tmuxCommands.map(command => [command.cmd, ...command.args].join(' '))
+    ]
+  };
+
+  console.log(JSON.stringify(preview, null, 2));
+}
+
+function main() {
+  const { execute, planPath, writeOnly } = parseArgs(process.argv);
+
+  if (!planPath) {
+    usage();
+    process.exit(1);
+  }
+
+  const { absolutePath, config } = loadPlanConfig(planPath);
+  const plan = buildOrchestrationPlan(config);
+
+  if (writeOnly) {
+    materializePlan(plan);
+    console.log(`Wrote orchestration files to ${plan.coordinationDir}`);
+    return;
+  }
+
+  if (!execute) {
+    printDryRun(plan, absolutePath);
+    return;
+  }
+
+  const result = executePlan(plan);
+  console.log([
+    `Started tmux session '${result.sessionName}' with ${result.workerCount} worker panes.`,
+    `Coordination files: ${result.coordinationDir}`,
+    `Attach with: tmux attach -t ${result.sessionName}`
+  ].join('\n'));
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`[orchestrate-worktrees] ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { main };

package/scripts/orchestration-status.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { inspectSessionTarget } = require('./lib/session-adapters/registry');
+
+function usage() {
+  console.log([
+    'Usage:',
+    '  node scripts/orchestration-status.js <session-name|plan.json> [--write <output.json>]',
+    '',
+    'Examples:',
+    '  node scripts/orchestration-status.js workflow-visual-proof',
+    '  node scripts/orchestration-status.js .claude/plan/workflow-visual-proof.json',
+    '  node scripts/orchestration-status.js .claude/plan/workflow-visual-proof.json --write /tmp/snapshot.json'
+  ].join('\n'));
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const target = args.find(arg => !arg.startsWith('--'));
+  const writeIndex = args.indexOf('--write');
+  const writePath = writeIndex >= 0 ? args[writeIndex + 1] : null;
+
+  return { target, writePath };
+}
+
+function main() {
+  const { target, writePath } = parseArgs(process.argv);
+
+  if (!target) {
+    usage();
+    process.exit(1);
+  }
+
+  const snapshot = inspectSessionTarget(target, {
+    cwd: process.cwd(),
+    adapterId: 'dmux-tmux'
+  });
+  const json = JSON.stringify(snapshot, null, 2);
+
+  if (writePath) {
+    const absoluteWritePath = path.resolve(writePath);
+    fs.mkdirSync(path.dirname(absoluteWritePath), { recursive: true });
+    fs.writeFileSync(absoluteWritePath, json + '\n', 'utf8');
+  }
+
+  console.log(json);
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`[orchestration-status] ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { main };

package/scripts/release.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Release script for bumping plugin version
+# Usage: ./scripts/release.sh VERSION
+
+VERSION="${1:-}"
+ROOT_PACKAGE_JSON="package.json"
+PLUGIN_JSON=".claude-plugin/plugin.json"
+MARKETPLACE_JSON=".claude-plugin/marketplace.json"
+OPENCODE_PACKAGE_JSON=".opencode/package.json"
+
+# Function to show usage
+usage() {
+  echo "Usage: $0 VERSION"
+  echo "Example: $0 1.5.0"
+  exit 1
+}
+
+# Validate VERSION is provided
+if [[ -z "$VERSION" ]]; then
+  echo "Error: VERSION argument is required"
+  usage
+fi
+
+# Validate VERSION is semver format (X.Y.Z)
+if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+  echo "Error: VERSION must be in semver format (e.g., 1.5.0)"
+  exit 1
+fi
+
+# Check current branch is main
+CURRENT_BRANCH=$(git branch --show-current)
+if [[ "$CURRENT_BRANCH" != "main" ]]; then
+  echo "Error: Must be on main branch (currently on $CURRENT_BRANCH)"
+  exit 1
+fi
+
+# Check working tree is clean
+if ! git diff --quiet || ! git diff --cached --quiet; then
+  echo "Error: Working tree is not clean. Commit or stash changes first."
+  exit 1
+fi
+
+# Verify versioned manifests exist
+for FILE in "$ROOT_PACKAGE_JSON" "$PLUGIN_JSON" "$MARKETPLACE_JSON" "$OPENCODE_PACKAGE_JSON"; do
+  if [[ ! -f "$FILE" ]]; then
+    echo "Error: $FILE not found"
+    exit 1
+  fi
+done
+
+# Read current version from plugin.json
+OLD_VERSION=$(grep -oE '"version": *"[^"]*"' "$PLUGIN_JSON" | head -1 | grep -oE '[0-9]+\.[0-9]+\.[0-9]+')
+if [[ -z "$OLD_VERSION" ]]; then
+  echo "Error: Could not extract current version from $PLUGIN_JSON"
+  exit 1
+fi
+echo "Bumping version: $OLD_VERSION -> $VERSION"
+
+update_version() {
+  local file="$1"
+  local pattern="$2"
+  if [[ "$OSTYPE" == "darwin"* ]]; then
+    sed -i '' "$pattern" "$file"
+  else
+    sed -i "$pattern" "$file"
+  fi
+}
+
+# Update all shipped package/plugin manifests
+update_version "$ROOT_PACKAGE_JSON" "s|\"version\": *\"[^\"]*\"|\"version\": \"$VERSION\"|"
+update_version "$PLUGIN_JSON" "s|\"version\": *\"[^\"]*\"|\"version\": \"$VERSION\"|"
+update_version "$MARKETPLACE_JSON" "0,/\"version\": *\"[^\"]*\"/s|\"version\": *\"[^\"]*\"|\"version\": \"$VERSION\"|"
+update_version "$OPENCODE_PACKAGE_JSON" "s|\"version\": *\"[^\"]*\"|\"version\": \"$VERSION\"|"
+
+# Stage, commit, tag, and push
+git add "$ROOT_PACKAGE_JSON" "$PLUGIN_JSON" "$MARKETPLACE_JSON" "$OPENCODE_PACKAGE_JSON"
+git commit -m "chore: bump plugin version to $VERSION"
+git tag "v$VERSION"
+git push origin main "v$VERSION"
+
+echo "Released v$VERSION"

package/scripts/repair.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+const os = require('os');
+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 || os.homedir(),
+      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
+};