@cairnkeep/cli 2.17.3 → 2.19.0

package/schemas/artifact.schema.json

@@ -27,7 +27,7 @@
       "properties": {
         "producer": { "type": "string", "minLength": 1, "maxLength": 256, "pattern": "^[^\\u0000-\\u001f\\u007f]+$" },
         "source_event": { "type": "string", "minLength": 1, "maxLength": 256 },
-        "harness": { "enum": ["claude-code", "opencode", "pi"] },
+        "harness": { "enum": ["claude-code", "opencode", "pi", "omp"] },
         "harness_version": { "type": "string", "minLength": 1, "maxLength": 128 },
         "native_id": { "type": "string", "minLength": 1, "maxLength": 256 }
       }

package/schemas/cairnkeep-setup-policy.schema.json

@@ -16,7 +16,7 @@
           "type": "array",
           "minItems": 1,
           "uniqueItems": true,
-          "items": {"enum": ["claude", "opencode", "pi", "kimi", "qwen", "codex"]}
+          "items": {"enum": ["claude", "opencode", "pi", "omp", "kimi", "qwen", "codex"]}
         },
         "memory": {"enum": ["local", "none"]}
       }
@@ -35,13 +35,13 @@
           "type": "array",
           "minItems": 1,
           "uniqueItems": true,
-          "items": {"enum": ["claude", "opencode", "pi", "kimi", "qwen", "codex"]}
+          "items": {"enum": ["claude", "opencode", "pi", "omp", "kimi", "qwen", "codex"]}
         },
         "required_harnesses": {
           "type": "array",
           "minItems": 1,
           "uniqueItems": true,
-          "items": {"enum": ["claude", "opencode", "pi", "kimi", "qwen", "codex"]}
+          "items": {"enum": ["claude", "opencode", "pi", "omp", "kimi", "qwen", "codex"]}
         },
         "memory": {
           "type": "array",

package/schemas/cairnkeep-setup.schema.json

@@ -14,7 +14,7 @@
       "type": "array",
       "minItems": 1,
       "uniqueItems": true,
-      "items": {"enum": ["claude", "opencode", "pi", "kimi", "qwen", "codex"]}
+      "items": {"enum": ["claude", "opencode", "pi", "omp", "kimi", "qwen", "codex"]}
     },
     "assets": {
       "type": "object",

package/scripts/cairn-cli.mjs

@@ -30,6 +30,7 @@ const POSIX_COMMANDS = new Map([
   ["sync", "sync-claude-assets.sh"],
   ["sync-pi", "sync-pi-assets.sh"],
   ["sync-kimi", "sync-kimi-assets.sh"],
+  ["sync-omp", "sync-omp-assets.sh"],
   ["audit-timer", "install-audit-timer.sh"],
   ["completion", "completion.sh"],
 ]);
@@ -44,6 +45,7 @@ Usage:
   cairn sync [--check|--apply] [--live-root DIR]
   cairn sync-pi [--check|--apply] [--live-root DIR]
   cairn sync-kimi [--check|--apply] [--live-root DIR]
+  cairn sync-omp [--check|--apply] [--live-root DIR]
   cairn doctor [--repair]
   cairn trajectory <list|show|prune>
   cairn proposals <create|list|show|apply|doctor>

package/scripts/completion.sh

@@ -13,7 +13,7 @@ _cairn_complete() {
   COMPREPLY=()
   current=${COMP_WORDS[COMP_CWORD]}
   previous=${COMP_WORDS[COMP_CWORD-1]:-}
-  commands="bootstrap setup memory-server sync sync-pi sync-kimi doctor trajectory artifact evidence playbook capabilities mcp-tools pack proposals notes eval skill graph memory audit-timer uninstall completion version help"
+  commands="bootstrap setup memory-server sync sync-pi sync-kimi sync-omp doctor trajectory artifact evidence playbook capabilities mcp-tools pack proposals notes eval skill graph memory audit-timer uninstall completion version help"
   if (( COMP_CWORD == 1 )); then
     COMPREPLY=( $(compgen -W "$commands" -- "$current") )
     return
@@ -24,6 +24,7 @@ _cairn_complete() {
     sync) COMPREPLY=( $(compgen -W "--apply --live-root" -- "$current") ) ;;
     sync-pi) COMPREPLY=( $(compgen -W "--apply --live-root" -- "$current") ) ;;
     sync-kimi) COMPREPLY=( $(compgen -W "--apply --live-root" -- "$current") ) ;;
+    sync-omp) COMPREPLY=( $(compgen -W "--apply --live-root" -- "$current") ) ;;
     doctor) COMPREPLY=( $(compgen -W "--repair" -- "$current") ) ;;
     trajectory) COMPREPLY=( $(compgen -W "list show prune --json --dry-run" -- "$current") ) ;;
     artifact) COMPREPLY=( $(compgen -W "list show delete prune --kind --session --json --dry-run --include-protected" -- "$current") ) ;;
@@ -94,6 +95,7 @@ _cairn() {
     'sync:install the Claude operating layer'
     'sync-pi:install the Pi trajectory extension and graph prompt'
     'sync-kimi:install the Kimi graph Skill'
+    'sync-omp:install the oh-my-pi memory extension'
     'doctor:check runtime dependencies and endpoints'
     'trajectory:inspect and prune local session trajectories'
     'artifact:inspect, delete, and prune local artifacts'
@@ -124,6 +126,7 @@ _cairn() {
     sync) _arguments '--apply[apply changes]' '--live-root[project Claude root]:directory:_files -/' ;;
     sync-pi) _arguments '--apply[apply changes]' '--live-root[Pi agent root]:directory:_files -/' ;;
     sync-kimi) _arguments '--apply[apply changes]' '--live-root[Kimi Code root]:directory:_files -/' ;;
+    sync-omp) _arguments '--apply[apply changes]' '--live-root[omp agent root]:directory:_files -/' ;;
     doctor) _arguments '--repair[repair trajectory metadata and indexes]' ;;
     trajectory) _values 'trajectory command' list show prune ;;
     artifact)
@@ -188,8 +191,8 @@ EOF
   fish)
     sed "s/__CAIRN_HARNESSES__/$harnesses/g" <<'EOF'
 complete -c cairn -f
-for command in bootstrap setup memory-server sync sync-pi sync-kimi doctor trajectory artifact evidence playbook capabilities mcp-tools pack proposals notes eval skill graph memory audit-timer uninstall completion version help
-complete -c cairn -n "not __fish_seen_subcommand_from bootstrap setup memory-server sync sync-pi sync-kimi doctor trajectory artifact evidence playbook capabilities mcp-tools pack proposals notes eval skill graph memory audit-timer uninstall completion version help" -a $command
+for command in bootstrap setup memory-server sync sync-pi sync-kimi sync-omp doctor trajectory artifact evidence playbook capabilities mcp-tools pack proposals notes eval skill graph memory audit-timer uninstall completion version help
+complete -c cairn -n "not __fish_seen_subcommand_from bootstrap setup memory-server sync sync-pi sync-kimi sync-omp doctor trajectory artifact evidence playbook capabilities mcp-tools pack proposals notes eval skill graph memory audit-timer uninstall completion version help" -a $command
 end
 complete -c cairn -n "__fish_seen_subcommand_from sync" -l apply
 complete -c cairn -n "__fish_seen_subcommand_from sync" -l live-root -r
@@ -197,6 +200,8 @@ complete -c cairn -n "__fish_seen_subcommand_from sync-pi" -l apply
 complete -c cairn -n "__fish_seen_subcommand_from sync-pi" -l live-root -r
 complete -c cairn -n "__fish_seen_subcommand_from sync-kimi" -l apply
 complete -c cairn -n "__fish_seen_subcommand_from sync-kimi" -l live-root -r
+complete -c cairn -n "__fish_seen_subcommand_from sync-omp" -l apply
+complete -c cairn -n "__fish_seen_subcommand_from sync-omp" -l live-root -r
 complete -c cairn -n "__fish_seen_subcommand_from bootstrap" -l untracked
 complete -c cairn -n "__fish_seen_subcommand_from setup" -l git -r -a "init existing none"
 complete -c cairn -n "__fish_seen_subcommand_from setup" -l harness -r -a "__CAIRN_HARNESSES__"

package/scripts/harness-registry.mjs

@@ -28,6 +28,13 @@ const DEFINITIONS = [
     project_assets: [],
     machine_sync: "cairn sync-pi --apply",
   },
+  {
+    id: "omp",
+    title: "Oh My Pi (OMP)",
+    launcher: { template: "start-omp.sh.template", path: ".ai/start-omp.sh", mode: 0o755 },
+    project_assets: [],
+    machine_sync: "cairn sync-omp --apply",
+  },
   {
     id: "kimi",
     title: "Kimi Code",
@@ -90,9 +97,14 @@ export function requiredHarnessAssetPaths(harnesses, memory = "local") {
 }
 
 export function machineSyncCommand(harnesses) {
-  const commands = harnesses.map(harnessDefinition).map((definition) => definition?.machine_sync).filter(Boolean);
-  if (commands.includes("cairn sync-pi --apply")) return "cairn sync-pi --apply";
-  return commands[0] ?? null;
+  const commands = machineSyncCommands(harnesses);
+  return commands.find((command) => command === "cairn sync-pi --apply") ?? commands[0] ?? null;
+}
+
+export function machineSyncCommands(harnesses) {
+  return Object.freeze([...new Set(
+    harnesses.map(harnessDefinition).map((definition) => definition?.machine_sync).filter(Boolean),
+  )]);
 }
 
 function validateRegistry() {

package/scripts/lib/omp-capture-stage.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+// omp capture staging child for the cairnkeep-capture extension.
+//
+// Reads transcript text on stdin, runs the shared extraction
+// (`node <server-entry> extract <model>`, stdin-piped — transcript text is
+// never interpolated into a shell line), and stages the candidate JSON under
+// <repo>/.planning/memory-staging/ with the exact same filename, JSON, and
+// retention-cap-5 contract as stageCandidates in opencode/plugins/memory-capture.ts.
+//
+// Invoked detached + unref'd by the extension so staging completes even when
+// the agent process exits before extraction returns. Fail-open: always exits 0.
+//
+// Usage: node omp-capture-stage.mjs <repo> <server-entry> <model>
+
+import { spawn } from "node:child_process";
+import { mkdirSync, readdirSync, writeFileSync, unlinkSync, statSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const RETENTION_CAP = 5;
+const EXTRACT_TIMEOUT_MS = 120_000;
+
+const [, , repo, serverEntry, model] = process.argv;
+
+function stageCandidates(repoRoot, candidatesJson) {
+  const stagingDir = join(repoRoot, ".planning", "memory-staging");
+  mkdirSync(stagingDir, { recursive: true });
+  const ts = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  const stageFile = join(stagingDir, `${ts}.json`);
+  writeFileSync(stageFile, `${candidatesJson}\n`);
+
+  // Keep the staging dir bounded — drop the oldest beyond 5 sessions.
+  const staged = readdirSync(stagingDir)
+    .filter((f) => f.endsWith(".json"))
+    .map((f) => ({ f, mtime: statSync(join(stagingDir, f)).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime);
+  for (const { f } of staged.slice(RETENTION_CAP)) {
+    unlinkSync(join(stagingDir, f));
+  }
+  return stageFile;
+}
+
+function runExtract(entry, extractModel, input) {
+  return new Promise((resolvePromise) => {
+    let stdout = "";
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise(stdout);
+    };
+    const child = spawn("node", [entry, "extract", extractModel], { stdio: ["pipe", "pipe", "ignore"] });
+    const timer = setTimeout(() => {
+      try { child.kill("SIGKILL"); } catch { /* best-effort kill only */ }
+    }, EXTRACT_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      if (stdout.length > 1024 * 1024) {
+        stdout = "";
+        try { child.kill("SIGKILL"); } catch { /* best-effort kill only */ }
+      }
+    });
+    child.on("close", finish);
+    child.on("error", finish);
+    child.stdin.on("error", () => {
+      // EPIPE after a failed/terminated child is part of the fail-open path.
+    });
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+
+async function main() {
+  if (!repo || !serverEntry || !model || !existsSync(serverEntry)) return;
+  let input = "";
+  try {
+    for await (const chunk of process.stdin) input += chunk.toString("utf8");
+  } catch {
+    return;
+  }
+  input = input.trim();
+  if (!input) return;
+
+  const candidatesJson = (await runExtract(serverEntry, model, input)).trim();
+  if (!candidatesJson) return;
+
+  let parsed;
+  try {
+    parsed = JSON.parse(candidatesJson);
+  } catch {
+    return;
+  }
+  if (!Array.isArray(parsed.candidates) || parsed.candidates.length === 0) return;
+
+  stageCandidates(repo, candidatesJson);
+}
+
+try {
+  await main();
+} catch {
+  // Fail open — staging is best-effort.
+}
+process.exit(0);

package/scripts/setup.mjs

@@ -22,7 +22,7 @@ import {
   resolveSetupChoices,
 } from "./setup-core.mjs";
 import { reconcileSetupPlan } from "./setup-reconcile.mjs";
-import { HARNESS_IDS, HARNESS_REGISTRY, machineSyncCommand, requiredHarnessAssetPaths } from "./harness-registry.mjs";
+import { HARNESS_IDS, HARNESS_REGISTRY, machineSyncCommand, machineSyncCommands, requiredHarnessAssetPaths } from "./harness-registry.mjs";
 import { reconcilePlaybookInstructions } from "./playbook-instructions.mjs";
 import { selectManyPrompt, selectOnePrompt, supportsTerminalPrompts } from "./terminal-prompts.mjs";
 
@@ -189,6 +189,7 @@ function setupRecovery(plan) {
 }
 
 function resultFor(plan, reconciliation, platform) {
+  const machineCommands = machineSyncCommands(plan.harnesses);
   const machineCommand = machineSyncCommand(plan.harnesses);
   return Object.freeze({
     schema_version: 1,
@@ -203,7 +204,7 @@ function resultFor(plan, reconciliation, platform) {
     launch_commands: Object.freeze(launchCommands(plan, platform)),
     recovery: Object.freeze(setupRecovery(plan)),
     limitations: Object.freeze(plan.limited ? ["Git integration is disabled; repository-aware features are limited."] : []),
-    machine_sync: Object.freeze({ automatic: false, command: machineCommand }),
+    machine_sync: Object.freeze({ automatic: false, command: machineCommand, commands: machineCommands }),
   });
 }
 
@@ -223,9 +224,13 @@ export function renderSetupResult(result, stream) {
   if (result.harnesses.includes("codex") && result.memory === "local") {
     writeLine(stream, "Codex: review .codex/config.toml and accept the project trust prompt before use");
   }
-  writeLine(stream, result.machine_sync.command
-    ? `Machine sync: ${result.machine_sync.command} (not run automatically)`
-    : "Machine sync: not required for the selected harnesses");
+  if (result.machine_sync.commands.length > 0) {
+    for (const command of result.machine_sync.commands) {
+      writeLine(stream, `Machine sync: ${command} (not run automatically)`);
+    }
+  } else {
+    writeLine(stream, "Machine sync: not required for the selected harnesses");
+  }
 }
 
 function createTarget(target) {

package/scripts/sync-omp-assets.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage: sync-omp-assets.sh [--check|--apply] [--live-root PATH]
+
+Compare or sync the repo-managed oh-my-pi (omp) extension asset against the
+live omp agent configuration tree.
+
+Options:
+  --check            Verify managed live assets match the rendered repo copies (default)
+  --apply            Install managed assets, then verify
+  --live-root PATH   Override the omp agent root (default: $PI_CODING_AGENT_DIR or ~/.omp/agent)
+  -h, --help         Show this help text
+EOF
+}
+
+ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+SOURCE_ROOT="$ROOT_DIR/omp"
+LIVE_ROOT="${PI_CODING_AGENT_DIR:-$HOME/.omp/agent}"
+MODE="check"
+ASSETS=(
+  "extensions/cairnkeep-memory.ts"
+  "extensions/cairnkeep-capture.ts"
+)
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --check) MODE="check"; shift ;;
+    --apply) MODE="apply"; shift ;;
+    --live-root) LIVE_ROOT="$2"; shift 2 ;;
+    -h|--help) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage >&2; exit 2 ;;
+  esac
+done
+
+render_asset() {
+  local rel="$1"
+  if [[ "$rel" == extensions/*.ts ]]; then
+    sed "s|@@INFRA_ROOT@@|$ROOT_DIR|g" "$SOURCE_ROOT/$rel"
+  else
+    cat "$SOURCE_ROOT/$rel"
+  fi
+}
+
+ensure_sources() {
+  local rel
+  for rel in "${ASSETS[@]}"; do
+    [[ -f "$SOURCE_ROOT/$rel" ]] || {
+      echo "Missing repo-managed source asset: $SOURCE_ROOT/$rel" >&2
+      return 2
+    }
+  done
+}
+
+check_assets() {
+  local rel
+  local failed=0
+  for rel in "${ASSETS[@]}"; do
+    if [[ ! -f "$LIVE_ROOT/$rel" ]]; then
+      echo "Missing live omp asset under $LIVE_ROOT: $rel" >&2
+      failed=1
+    elif ! cmp -s <(render_asset "$rel") "$LIVE_ROOT/$rel"; then
+      echo "Out-of-sync live omp asset under $LIVE_ROOT: $rel" >&2
+      failed=1
+    fi
+  done
+  return "$failed"
+}
+
+ensure_sources
+
+if [[ "$MODE" == "apply" ]]; then
+  updated=0
+  unchanged=0
+  for rel in "${ASSETS[@]}"; do
+    mkdir -p "$(dirname "$LIVE_ROOT/$rel")"
+    if [[ -f "$LIVE_ROOT/$rel" ]] && cmp -s <(render_asset "$rel") "$LIVE_ROOT/$rel"; then
+      unchanged=$((unchanged + 1))
+      continue
+    fi
+    rendered_tmp=$(mktemp)
+    render_asset "$rel" > "$rendered_tmp"
+    install -m 0644 "$rendered_tmp" "$LIVE_ROOT/$rel"
+    rm -f "$rendered_tmp"
+    updated=$((updated + 1))
+  done
+  printf 'Applied %s omp asset(s); %s already matched.\n' "$updated" "$unchanged"
+fi
+
+if ! check_assets; then
+  echo "Recovery: sync-omp-assets.sh --apply --live-root PATH" >&2
+  exit 1
+fi
+printf 'omp extensions are in sync under %s\n' "$LIVE_ROOT"

package/scripts/test-bootstrap-untracked.sh

@@ -90,7 +90,7 @@ grep -qxF "/.agentfs/" "$tmp/repo/.git/info/exclude" || fail "missing /.agentfs/
 printf '%s\n' '{"schema_version":1,"capabilities":{"wiki":false},"logging":{"callbacks":true}}' >"$tmp/repo/.ai/capabilities.json"
 chmod 600 "$tmp/repo/.ai/capabilities.json"
 printf '%s\n' '# operator-owned environment' >"$tmp/repo/.ai/env.example"
-asset_paths='.ai/start-claude.sh .ai/start-opencode.sh .ai/start-pi.sh .ai/start-kimi.sh .ai/start-qwen.sh .ai/start-codex.sh .ai/env.example .ai/trajectory-redaction.json .ai/capabilities.json .agentfs/.gitignore .planning/config.json .planning/wiki/index.md .planning/wiki/policy.md .planning/wiki/CONTRADICTIONS.md .planning/wiki/LOG.md .planning/alignment/policy.md .planning/alignment/gap-register.yaml .planning/graphs/policy.md .planning/graphs/.gitignore .planning/security/policy.md'
+asset_paths='.ai/start-claude.sh .ai/start-opencode.sh .ai/start-pi.sh .ai/start-omp.sh .ai/start-kimi.sh .ai/start-qwen.sh .ai/start-codex.sh .ai/env.example .ai/trajectory-redaction.json .ai/capabilities.json .agentfs/.gitignore .planning/config.json .planning/wiki/index.md .planning/wiki/policy.md .planning/wiki/CONTRADICTIONS.md .planning/wiki/LOG.md .planning/alignment/policy.md .planning/alignment/gap-register.yaml .planning/graphs/policy.md .planning/graphs/.gitignore .planning/security/policy.md'
 mkdir -p "$tmp/assets-before"
 for path in $asset_paths; do
   cp "$tmp/repo/$path" "$tmp/assets-before/${path//\//__}"

package/scripts/test-cli-dispatch.sh

@@ -12,6 +12,7 @@ tmp=$(mktemp -d); trap 'rm -rf "$tmp"' EXIT
 "$cairn" help | grep -q "cairn sync" || fail "help missing sync"
 "$cairn" help | grep -q "cairn sync-pi" || fail "help missing sync-pi"
 "$cairn" help | grep -q "cairn sync-kimi" || fail "help missing sync-kimi"
+"$cairn" help | grep -q "cairn sync-omp" || fail "help missing sync-omp"
 "$cairn" help | grep -q "cairn memory-server" || fail "help missing memory-server"
 "$cairn" help | grep -q "cairn notes" || fail "help missing notes"
 "$cairn" help | grep -q "cairn artifact <list|show|delete|prune>" || fail "help missing artifact"
@@ -24,6 +25,7 @@ tmp=$(mktemp -d); trap 'rm -rf "$tmp"' EXIT
 "$cairn" sync --help >/dev/null 2>&1 || fail "cairn sync dispatch"
 "$cairn" sync-pi --help >/dev/null 2>&1 || fail "cairn sync-pi dispatch"
 "$cairn" sync-kimi --help >/dev/null 2>&1 || fail "cairn sync-kimi dispatch"
+"$cairn" sync-omp --help >/dev/null 2>&1 || fail "cairn sync-omp dispatch"
 env -u CAIRN_NOTE_DISTILLATION "$cairn" notes --help >/dev/null 2>&1 || fail "cairn notes dispatch"
 "$cairn" artifact --help | grep -q "cairn artifact list" || fail "cairn artifact dispatch"
 "$cairn" evidence --help | grep -q "cairn evidence list" || fail "cairn evidence dispatch"

package/scripts/test-completion.sh

@@ -109,12 +109,14 @@ for shell in bash zsh; do
   grep -q 'sync-pi' "$tmp/$shell"
   grep -q 'codex' "$tmp/$shell"
   grep -q 'sync-kimi' "$tmp/$shell"
+  grep -q 'sync-omp' "$tmp/$shell"
   grep -q -- '--live-root' "$tmp/$shell"
 done
 grep -q 'sync-pi' "$tmp/fish"
 grep -q 'codex' "$tmp/fish"
 grep -q 'sync-kimi' "$tmp/fish"
-grep -q 'not __fish_seen_subcommand_from .*sync-pi sync-kimi' "$tmp/fish"
+grep -q 'sync-omp' "$tmp/fish"
+grep -q 'not __fish_seen_subcommand_from .*sync-pi sync-kimi sync-omp' "$tmp/fish"
 grep -q -- '-l live-root' "$tmp/fish"
 for shell in bash zsh fish; do
   grep -q 'notes' "$tmp/$shell"
@@ -163,7 +165,7 @@ if [[ "$completion_surface_complete" != true ]]; then
 fi
 
 setup_flags='--git --harness --memory --policy --yes --json'
-setup_values='init existing none claude opencode pi kimi qwen local'
+setup_values='init existing none claude opencode pi omp kimi qwen codex local'
 for shell in bash zsh fish powershell; do
   for flag in $setup_flags; do
     grep -q -- "$flag\|${flag#--}" "$tmp/$shell" || {

package/scripts/test-harness-registry.sh

@@ -25,7 +25,7 @@ for (const path of [
   assert.match(content, /approval/);
 }
 const registry = await import(pathToFileURL(join(root, "scripts", "harness-registry.mjs")).href);
-assert.deepEqual(registry.HARNESS_IDS, ["claude", "opencode", "pi", "kimi", "qwen", "codex"]);
+assert.deepEqual(registry.HARNESS_IDS, ["claude", "opencode", "pi", "omp", "kimi", "qwen", "codex"]);
 assert.equal(new Set(registry.HARNESS_IDS).size, registry.HARNESS_IDS.length);
 for (const id of registry.HARNESS_IDS) {
   const definition = registry.harnessDefinition(id);
@@ -40,6 +40,14 @@ assert.deepEqual(registry.harnessProjectAssets("codex", "local").map(({ path })
 assert.deepEqual(registry.requiredHarnessAssetPaths(["codex"], "local"), [".ai/start-codex.sh"]);
 assert.deepEqual(registry.requiredHarnessAssetPaths(["codex"], "none"), [".ai/start-codex.sh"]);
 assert.equal(registry.machineSyncCommand(["codex"]), null);
+assert.deepEqual(registry.machineSyncCommands(["claude", "opencode", "pi", "omp", "kimi"]), [
+  "cairn sync --apply",
+  "cairn sync-pi --apply",
+  "cairn sync-omp --apply",
+  "cairn sync-kimi --apply",
+]);
+assert.equal(registry.machineSyncCommand(["claude", "pi"]), "cairn sync-pi --apply", "legacy singular machine sync should retain its Pi preference");
+assert.deepEqual(registry.machineSyncCommands(["codex"]), []);
 
 const schema = JSON.parse(readFileSync(join(root, "schemas", "cairnkeep-setup.schema.json"), "utf8"));
 assert.deepEqual(schema.properties.harnesses.items.enum, registry.HARNESS_IDS, "setup schema drifted from harness registry");
@@ -56,6 +64,7 @@ assert.equal(setup.status, 0, setup.stderr);
 const result = JSON.parse(setup.stdout);
 assert.deepEqual(result.harnesses, ["codex"]);
 assert.equal(result.machine_sync.command, null);
+assert.deepEqual(result.machine_sync.commands, []);
 assert.deepEqual(result.launch_commands, [".ai/start-codex.sh"]);
 assert.match(readFileSync(join(target, ".codex", "config.toml"), "utf8"), /\[mcp_servers\.cairn-memory-local\][\s\S]*command = "cairn"[\s\S]*args = \["memory-server"\]/);
 
@@ -73,6 +82,24 @@ const launch = spawnSync(join(target, ".ai", "start-codex.sh"), ["--fixture"], {
 assert.equal(launch.status, 0, launch.stderr);
 assert.deepEqual(launch.stdout.trim().split("\n"), [target, "loaded", "--fixture"]);
 
+const ompTarget = join(sandbox, "omp-project");
+const ompSetup = spawnSync(join(root, "bin", "cairn"), [
+  "setup", ompTarget, "--git", "init", "--harness", "omp", "--memory", "local", "--yes", "--json",
+], { encoding: "utf8", shell: false });
+assert.equal(ompSetup.status, 0, ompSetup.stderr);
+assert.deepEqual(JSON.parse(ompSetup.stdout).harnesses, ["omp"]);
+const fakeOmp = join(fakeBin, "omp");
+writeFileSync(fakeOmp, "#!/bin/sh\nprintf '%s\\n' \"$PWD\" \"${CAIRN_REGISTRY_TEST:-}\" \"$*\"\n");
+chmodSync(fakeOmp, 0o755);
+writeFileSync(join(ompTarget, ".ai", ".env"), "CAIRN_REGISTRY_TEST=omp-loaded\n", { mode: 0o600 });
+const ompLaunch = spawnSync(join(ompTarget, ".ai", "start-omp.sh"), ["--fixture"], {
+  encoding: "utf8",
+  shell: false,
+  env: { ...process.env, PATH: `${fakeBin}:${process.env.PATH}` },
+});
+assert.equal(ompLaunch.status, 0, ompLaunch.stderr);
+assert.deepEqual(ompLaunch.stdout.trim().split("\n"), [ompTarget, "omp-loaded", "--fixture"]);
+
 const noMemory = join(sandbox, "codex-no-memory");
 const noMemorySetup = spawnSync(join(root, "bin", "cairn"), [
   "setup", noMemory, "--git", "init", "--harness", "codex", "--memory", "none", "--yes",

package/scripts/test-setup-output.sh

@@ -68,6 +68,7 @@ assert.equal(result.launch_commands.some((line) => /start-pi\.sh/.test(line)), t
 assert.equal(Array.isArray(result.recovery), true);
 assert.equal(result.machine_sync.automatic, false);
 assert.match(result.machine_sync.command, /^cairn sync(?:-pi)? --(?:check|apply)/);
+assert.deepEqual(result.machine_sync.commands, ["cairn sync --apply", "cairn sync-pi --apply"]);
 NODE
 
 complete_human="$tmp/complete.txt"
@@ -86,7 +87,25 @@ for expected in \
   "Recovery:"; do
   grep -qF "$expected" "$complete_human" || fail "human output missing $expected"
 done
-grep -qE 'cairn sync(-pi)? --(check|apply)' "$complete_human" || fail "human output omitted explicit machine sync direction"
+grep -qF 'Machine sync: cairn sync --apply (not run automatically)' "$complete_human" || fail "human output omitted Claude machine sync"
+grep -qF 'Machine sync: cairn sync-pi --apply (not run automatically)' "$complete_human" || fail "human output omitted Pi machine sync"
+
+omp_json="$tmp/omp.json"
+"$ROOT/bin/cairn" setup "$tmp/omp target" \
+  --git init --harness omp --memory local --yes --json >"$omp_json"
+node --input-type=module - "$omp_json" <<'NODE'
+import assert from "node:assert/strict";
+import fs from "node:fs";
+
+const result = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
+assert.deepEqual(result.harnesses, ["omp"]);
+assert.deepEqual(result.launch_commands, [".ai/start-omp.sh"]);
+assert.equal(result.machine_sync.automatic, false);
+assert.equal(result.machine_sync.command, "cairn sync-omp --apply");
+assert.deepEqual(result.machine_sync.commands, ["cairn sync-omp --apply"]);
+NODE
+[[ -x "$tmp/omp target/.ai/start-omp.sh" ]] || fail "OMP launcher missing"
+grep -qF 'cairn evidence run --harness omp -- omp' "$tmp/omp target/.ai/start-omp.sh" || fail "OMP launcher work-evidence integration missing"
 
 limited_json="$tmp/limited.json"
 "$ROOT/bin/cairn" setup "$tmp/limited target" \

package/scripts/test-setup-preflight.mjs

@@ -345,7 +345,7 @@ async function testStructuredSetupSelectors(setup, fixture) {
     "Apply this setup plan?",
   ]);
   const harnessPrompt = selections.find(({ message }) => message === "Coding harnesses");
-  assert.deepEqual(harnessPrompt.choices.map(({ value }) => value), ["claude", "opencode", "pi", "kimi", "qwen", "codex"]);
+  assert.deepEqual(harnessPrompt.choices.map(({ value }) => value), ["claude", "opencode", "pi", "omp", "kimi", "qwen", "codex"]);
   assert.match(harnessPrompt.choices.find(({ value }) => value === "codex").label, /Codex CLI/);
   assertNoManagedPaths(fixture.empty, "cancelled structured setup");
 }

package/scripts/test-work-evidence-cli.sh

@@ -16,7 +16,7 @@ exec node "$ROOT/bin/cairn" "\$@"
 EOF
 chmod +x "$fake_bin/cairn"
 
-for harness in claude opencode pi kimi qwen codex; do
+for harness in claude opencode pi omp kimi qwen codex; do
   project="$tmp/$harness"
   mkdir -p "$project/.ai" "$project/.agentfs"
   cp "$ROOT/templates/start-$harness.sh.template" "$project/.ai/start-$harness.sh"

package/scripts/uninstall.sh

@@ -43,6 +43,7 @@ PROJECT_AI_FILES=(
   start-claude.sh
   start-opencode.sh
   start-pi.sh
+  start-omp.sh
   start-kimi.sh
   start-qwen.sh
   start-codex.sh