@lamentis/naome 1.3.0 → 1.3.2

package/crates/naome-core/tests/workflow_agent.rs

@@ -0,0 +1,233 @@
+mod workflow_agent_support;
+
+use naome_core::{
+    agent_run_plan, context_delta_report, decision_gate, edit_session_watchdog,
+    proof_plan_for_task, repository_capability_graph, summarize_command_output, CommandCheckResult,
+};
+
+use workflow_agent_support::Repo;
+
+#[test]
+fn execution_plan_ledger_orders_read_edit_and_check_steps() {
+    let repo = Repo::new("execution-plan");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["unit"]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let plan = agent_run_plan(repo.path()).unwrap();
+
+    assert_eq!(plan.schema, "naome.agent-run-plan.v1");
+    assert_eq!(plan.execution_plan.task_state, "implementing");
+    assert!(plan.execution_plan.steps.iter().any(|step| {
+        step.id == "read-required-context"
+            && step.reason_codes.contains(&"token-economy".to_string())
+    }));
+    assert!(plan.execution_plan.steps.iter().any(|step| {
+        step.id == "run-path-quality" && step.paths == vec!["src/lib.rs".to_string()]
+    }));
+    assert!(plan.execution_plan.steps.iter().all(|step| {
+        !step
+            .commands
+            .iter()
+            .any(|command| command.contains(".naome/task-state.json"))
+    }));
+    assert!(plan
+        .execution_plan
+        .steps
+        .iter()
+        .any(|step| step.id == "run-progress-gate"));
+}
+
+#[test]
+fn context_delta_marks_reusable_unread_and_stale_context() {
+    let repo = Repo::new("context-delta");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["unit"]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let delta = context_delta_report(
+        repo.path(),
+        &[
+            "docs/naome/testing.md".to_string(),
+            "src/lib.rs".to_string(),
+        ],
+    )
+    .unwrap();
+
+    assert_eq!(delta.schema, "naome.context-delta.v1");
+    assert!(delta
+        .reusable_context
+        .contains(&"docs/naome/testing.md".to_string()));
+    assert!(delta.stale_context.contains(&"src/lib.rs".to_string()));
+    assert!(delta
+        .unread_required_context
+        .contains(&".naome/task-state.json".to_string()));
+}
+
+#[test]
+fn proof_planner_recommends_minimal_missing_checks_in_phase_order() {
+    let repo = Repo::new("proof-plan");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["shape", "unit", "pack"]);
+    repo.write_phased_verification();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let plan = proof_plan_for_task(
+        repo.path(),
+        &[CommandCheckResult {
+            check_id: "shape".to_string(),
+            exit_code: 0,
+        }],
+    )
+    .unwrap();
+
+    assert_eq!(plan.schema, "naome.proof-plan.v1");
+    assert_eq!(plan.recommended_check_ids, vec!["unit".to_string()]);
+    assert!(plan.withheld_check_ids.contains(&"pack".to_string()));
+    assert_eq!(plan.evidence_paths, vec!["src/lib.rs".to_string()]);
+}
+
+#[test]
+fn proof_planner_recommends_semantic_changed_gate_with_repository_quality() {
+    let repo = Repo::new("proof-plan-semantic");
+    repo.write_harness_state(
+        "implementing",
+        &["src/lib.rs"],
+        &[
+            "repository-quality-check",
+            "repository-semantic-check",
+            "package",
+        ],
+    );
+    repo.write_verification(&[
+        (
+            "repository-quality-check",
+            "node .naome/bin/naome.js quality check --changed",
+            "fast",
+        ),
+        (
+            "repository-semantic-check",
+            "node .naome/bin/naome.js semantic check --changed",
+            "fast",
+        ),
+        ("package", "npm run pack:dry-run", "slow"),
+    ]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let plan = proof_plan_for_task(repo.path(), &[]).unwrap();
+
+    assert_eq!(
+        plan.recommended_check_ids,
+        vec![
+            "repository-quality-check".to_string(),
+            "repository-semantic-check".to_string()
+        ]
+    );
+    assert!(plan.withheld_check_ids.contains(&"package".to_string()));
+}
+
+#[test]
+fn output_digest_keeps_relevant_lines_paths_and_artifacts() {
+    let output = [
+        "running 2 tests",
+        "error: failed at src/lib.rs:4",
+        "full log written to target/test-output/fail.log",
+        "noise line",
+    ]
+    .join("\n");
+
+    let digest = summarize_command_output("cargo test", ".", 101, &output, 3);
+
+    assert!(digest.truncated);
+    assert!(digest
+        .relevant_lines
+        .iter()
+        .any(|line| line.contains("error")));
+    assert!(digest.affected_paths.contains(&"src/lib.rs".to_string()));
+    assert!(digest
+        .artifacts
+        .contains(&"target/test-output/fail.log".to_string()));
+}
+
+#[test]
+fn capability_graph_maps_stack_roots_and_checks() {
+    let repo = Repo::new("capability-graph");
+    repo.write_harness_state("idle", &[], &[]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file(
+        "Cargo.toml",
+        "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
+    );
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let graph = repository_capability_graph(repo.path()).unwrap();
+
+    assert_eq!(graph.schema, "naome.capability-graph.v1");
+    assert!(graph
+        .capabilities
+        .iter()
+        .any(|capability| capability.id == "language:rust"));
+    assert!(graph
+        .capabilities
+        .iter()
+        .any(|capability| capability.id == "build:cargo"));
+    assert!(graph
+        .verification_edges
+        .iter()
+        .any(|edge| edge.check_id == "unit"));
+}
+
+#[test]
+fn edit_watchdog_flags_scope_drift_and_recommends_early_gates() {
+    let repo = Repo::new("edit-watchdog");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["unit"]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+    repo.write_file("README.md", "# Demo\n");
+
+    let watchdog = edit_session_watchdog(
+        repo.path(),
+        &["src/lib.rs".to_string(), "README.md".to_string()],
+    )
+    .unwrap();
+
+    assert_eq!(watchdog.schema, "naome.edit-session-watchdog.v1");
+    assert!(watchdog
+        .next_commands
+        .contains(&"node .naome/bin/naome.js quality check --path src/lib.rs".to_string()));
+    assert!(watchdog.findings.iter().any(|finding| {
+        finding.check_id == "scope-drift" && finding.paths == vec!["README.md".to_string()]
+    }));
+}
+
+#[test]
+fn decision_gate_classifies_continue_vs_human_review() {
+    let repo = Repo::new("decision-gate");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["unit"]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let gate = decision_gate(repo.path()).unwrap();
+
+    assert_eq!(gate.schema, "naome.decision-gate.v1");
+    assert_eq!(gate.action, "continue");
+    assert!(gate
+        .reason_codes
+        .contains(&"active_task_in_progress".to_string()));
+
+    repo.write_file("README.md", "# Drift\n");
+    let drift_gate = decision_gate(repo.path()).unwrap();
+    assert_eq!(drift_gate.action, "ask_human");
+    assert!(drift_gate
+        .reason_codes
+        .contains(&"scope_review_required".to_string()));
+}

package/crates/naome-core/tests/workflow_agent_support/mod.rs

@@ -0,0 +1,159 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde_json::json;
+
+pub struct Repo {
+    root: PathBuf,
+}
+
+impl Repo {
+    pub fn new(name: &str) -> Self {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let counter = COUNTER.fetch_add(1, Ordering::Relaxed);
+        let root =
+            std::env::temp_dir().join(format!("naome-workflow-agent-{name}-{nonce}-{counter}"));
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        Self { root }
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.root
+    }
+
+    pub fn write_harness_state(&self, status: &str, allowed_paths: &[&str], checks: &[&str]) {
+        self.write_file(".naomeignore", ".naome/archive/\n");
+        self.write_json(".naome/init-state.json", json!({ "initialized": true }));
+        self.write_json(".naome/upgrade-state.json", json!({ "status": "complete" }));
+        self.write_json(
+            ".naome/task-state.json",
+            task_state(status, allowed_paths, checks),
+        );
+        self.write_file("docs/naome/testing.md", "# NAOME Testing\n");
+    }
+
+    pub fn write_verification(&self, checks: &[(&str, &str, &str)]) {
+        self.write_json(
+            ".naome/verification.json",
+            json!({
+                "schema": "naome.verification.v1",
+                "version": 1,
+                "status": "ready",
+                "checks": checks.iter().map(|(id, command, cost)| json!({
+                    "id": id,
+                    "command": command,
+                    "cwd": ".",
+                    "purpose": "test check",
+                    "cost": cost,
+                    "source": "test",
+                    "evidence": ["src/lib.rs"],
+                    "lastVerified": null
+                })).collect::<Vec<_>>(),
+                "changeTypes": [],
+                "releaseGates": []
+            }),
+        );
+    }
+
+    pub fn write_phased_verification(&self) {
+        self.write_verification(&[
+            (
+                "shape",
+                "node .naome/bin/check-task-state.js --progress",
+                "fast",
+            ),
+            ("unit", "cargo test", "fast"),
+            ("pack", "npm run pack:dry-run", "slow"),
+        ]);
+        let mut verification: serde_json::Value = serde_json::from_str(
+            &fs::read_to_string(self.root.join(".naome/verification.json")).unwrap(),
+        )
+        .unwrap();
+        verification["phases"] = json!([
+            { "id": "shape", "order": 1, "checkIds": ["shape"] },
+            { "id": "focused-tests", "order": 2, "checkIds": ["unit"] },
+            { "id": "package-release", "order": 3, "checkIds": ["pack"] }
+        ]);
+        self.write_json(".naome/verification.json", verification);
+    }
+
+    pub fn init_git(&self) {
+        self.git(&["init"]);
+        self.git(&["config", "user.email", "naome@example.com"]);
+        self.git(&["config", "user.name", "NAOME Test"]);
+        self.git(&["add", "."]);
+        self.git(&["commit", "-m", "baseline"]);
+    }
+
+    pub fn write_file(&self, relative_path: &str, content: &str) {
+        let path = self.root.join(relative_path);
+        fs::create_dir_all(path.parent().unwrap()).unwrap();
+        fs::write(path, content).unwrap();
+    }
+
+    fn git(&self, args: &[&str]) {
+        let output = Command::new("git")
+            .args(args)
+            .current_dir(&self.root)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "git {:?} failed\nstdout:\n{}\nstderr:\n{}",
+            args,
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    fn write_json(&self, relative_path: &str, value: serde_json::Value) {
+        self.write_file(
+            relative_path,
+            &format!("{}\n", serde_json::to_string_pretty(&value).unwrap()),
+        );
+    }
+}
+
+fn task_state(status: &str, allowed_paths: &[&str], checks: &[&str]) -> serde_json::Value {
+    json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": status,
+        "activeTask": {
+            "id": "demo-task",
+            "request": "Update demo.",
+            "userPrompt": {
+                "receivedAt": "2026-05-08T00:00:00.000Z",
+                "text": "Update demo."
+            },
+            "admission": {
+                "command": "node .naome/bin/check-task-state.js --admission",
+                "cwd": ".",
+                "exitCode": 0,
+                "checkedAt": "2026-05-08T00:00:00.000Z",
+                "gitHead": "",
+                "changedPaths": []
+            },
+            "allowedPaths": allowed_paths,
+            "declaredChangeTypes": ["harness-core"],
+            "requiredCheckIds": checks,
+            "proofResults": [],
+            "revisions": [],
+            "humanReview": {
+                "required": false,
+                "approved": false,
+                "reason": null
+            }
+        },
+        "blocker": null,
+        "updatedAt": "2026-05-08T00:00:00.000Z"
+    })
+}
+
+static COUNTER: AtomicU64 = AtomicU64::new(0);

package/crates/naome-core/tests/workflow_doctor.rs

@@ -22,3 +22,24 @@ fn doctor_report_explains_active_task_and_policy_files() {
         .next_action
         .contains("Finish or resolve the active task"));
 }
+
+#[test]
+fn doctor_report_marks_stale_repository_model() {
+    let repo = WorkflowFixture::new("doctor-repository-model-stale");
+    repo.init_git();
+    repo.write(".naome/repository-quality.json", "{}\n");
+    repo.write(".naome/repository-structure.json", "{}\n");
+    repo.write(".naome/repository-model.json", "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[]}\n");
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+
+    let report = doctor_report(repo.path()).unwrap();
+
+    assert!(!report.ok);
+    assert_eq!(report.repository_model.config_present, true);
+    assert_eq!(report.repository_model.status, "stale");
+    assert!(report
+        .repository_model
+        .messages
+        .iter()
+        .any(|message| message.contains("naome repo model --write")));
+}

package/crates/naome-core/tests/workflow_integrity.rs

@@ -5,8 +5,7 @@ use std::fs;
 use naome_core::{
     refresh_integrity, summarize_command_output, verification_phase_plan, CommandCheckResult,
 };
-use serde_json::json;
-use workflow_support::{check, phase, WorkflowFixture};
+use workflow_support::{phased_verification_fixture, WorkflowFixture};
 
 #[test]
 fn refresh_integrity_is_idempotent_and_repairs_manifest_hash() {
@@ -29,24 +28,7 @@ fn refresh_integrity_is_idempotent_and_repairs_manifest_hash() {
 #[test]
 fn failed_early_phase_withholds_expensive_recommendations() {
     let repo = WorkflowFixture::new("verification-phases");
-    repo.write_verification(json!({
-        "schema": "naome.verification.v1",
-        "version": 1,
-        "status": "ready",
-        "lastUpdated": "2026-05-07",
-        "checks": [
-            check("naome-harness-health", "node .naome/bin/check-harness-health.js", "fast"),
-            check("repository-quality-check", "node .naome/bin/naome.js quality check --changed", "fast"),
-            check("package-dry-run", "npm run pack:dry-run", "medium")
-        ],
-        "phases": [
-            phase("shape-health", 10, ["naome-harness-health"]),
-            phase("quality", 20, ["repository-quality-check"]),
-            phase("package-release", 50, ["package-dry-run"])
-        ],
-        "changeTypes": [],
-        "releaseGates": []
-    }));
+    repo.write_verification(phased_verification_fixture());
 
     let plan = verification_phase_plan(
         repo.path(),

package/crates/naome-core/tests/workflow_support/mod.rs

@@ -80,17 +80,10 @@ impl WorkflowFixture {
             checks,
             git_text(&self.root, &["rev-parse", "HEAD"]),
         );
-        self.write(
-            ".naome/task-state.json",
-            &pretty(json!({
-                "schema": "naome.task-state.v2",
-                "version": 2,
-                "status": status,
-                "activeTask": active_task,
-                "blocker": null,
-                "updatedAt": "2026-05-07T12:00:00.000Z"
-            })),
-        );
+        let mut task_state = task_state_template_fixture();
+        task_state["status"] = json!(status);
+        task_state["activeTask"] = active_task;
+        self.write(".naome/task-state.json", &pretty(task_state));
     }
 
     pub fn write_verification(&self, value: serde_json::Value) {
@@ -113,15 +106,32 @@ impl Drop for WorkflowFixture {
 }
 
 pub fn default_verification() -> serde_json::Value {
-    json!({
-        "schema": "naome.verification.v1",
-        "version": 1,
-        "status": "ready",
-        "lastUpdated": "2026-05-07",
-        "checks": [check("diff-check", "git diff --check", "fast")],
-        "changeTypes": [],
-        "releaseGates": []
-    })
+    let mut value = verification_template_fixture();
+    value["checks"] = json!([check("diff-check", "git diff --check", "fast")]);
+    value
+}
+
+pub fn phased_verification_fixture() -> serde_json::Value {
+    let mut value = verification_template_fixture();
+    value["checks"] = json!([
+        check(
+            "naome-harness-health",
+            "node .naome/bin/check-harness-health.js",
+            "fast"
+        ),
+        check(
+            "repository-quality-check",
+            "node .naome/bin/naome.js quality check --changed",
+            "fast"
+        ),
+        check("package-dry-run", "npm run pack:dry-run", "medium")
+    ]);
+    value["phases"] = json!([
+        phase("shape-health", 10, ["naome-harness-health"]),
+        phase("quality", 20, ["repository-quality-check"]),
+        phase("package-release", 50, ["package-dry-run"])
+    ]);
+    value
 }
 
 pub fn check(id: &str, command: &str, cost: &str) -> serde_json::Value {
@@ -159,6 +169,35 @@ fn active_task_state(
     })
 }
 
+fn task_state_template_fixture() -> serde_json::Value {
+    serde_json::from_str(
+        r#"{
+  "schema": "naome.task-state.v2",
+  "version": 2,
+  "status": null,
+  "activeTask": null,
+  "blocker": null,
+  "updatedAt": "2026-05-07T12:00:00.000Z"
+}"#,
+    )
+    .unwrap()
+}
+
+fn verification_template_fixture() -> serde_json::Value {
+    serde_json::from_str(
+        r#"{
+  "schema": "naome.verification.v1",
+  "version": 1,
+  "status": "ready",
+  "lastUpdated": "2026-05-07",
+  "checks": [],
+  "changeTypes": [],
+  "releaseGates": []
+}"#,
+    )
+    .unwrap()
+}
+
 fn admission_record(git_head: String) -> serde_json::Value {
     json!({
         "command": "node .naome/bin/check-task-state.js --admission",

package/installer/codex-hooks.js

@@ -0,0 +1,121 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { replaceHarnessFile } from "./harness-file-ops.js";
+import { printSection } from "./output.js";
+
+const HOOK_CONFIG_PATH = ".codex/hooks.json";
+const HOOK_FEATURE_CONFIG_PATH = ".codex/config.toml";
+const HOOK_DISPATCHER_PATH = ".naome/bin/codex-hook.js";
+const HOOK_IO_PATH = ".naome/bin/codex-hook-io.js";
+const HOOK_POLICY_PATH = ".naome/bin/codex-hook-policy.js";
+const HOOK_RUNTIME_PATH = ".naome/bin/codex-hook-runtime.js";
+const HOOK_DOC_PATH = "docs/naome/codex-hooks.md";
+
+const CODEX_HOOK_MACHINE_PATHS = [
+  HOOK_FEATURE_CONFIG_PATH,
+  HOOK_CONFIG_PATH,
+  HOOK_DISPATCHER_PATH,
+  HOOK_IO_PATH,
+  HOOK_POLICY_PATH,
+  HOOK_RUNTIME_PATH,
+  HOOK_DOC_PATH,
+];
+const CODEX_HOOK_EXECUTABLE_PATHS = [HOOK_DISPATCHER_PATH];
+
+export async function resolveCodexHooksPreference(ctx) {
+  const override = parseCodexHooksOverride(process.env.NAOME_CODEX_HOOKS);
+  if (override !== null) {
+    setCodexHooksEnabled(ctx, override);
+    return;
+  }
+
+  if (hasManagedCodexHooks(ctx)) {
+    setCodexHooksEnabled(ctx, true);
+    return;
+  }
+
+  if (!process.stdin.isTTY || process.env.CI === "true") {
+    setCodexHooksEnabled(ctx, false);
+    return;
+  }
+
+  printSection(ctx, "Optional Codex Hooks");
+  console.log(`${ctx.color.dim("purpose")} earlier NAOME feedback for Codex agents`);
+  console.log(`${ctx.color.dim("scope  ")} repo-local acceleration only; normal NAOME gates remain authoritative`);
+  console.log(`${ctx.color.dim("human ")} optional; declining keeps install and sync working`);
+  console.log("");
+
+  const rl = createInterface({ input, output });
+  const answer = await rl.question(`${ctx.color.yellow("?")} Install optional Codex Hooks for this repository? (y/N) `);
+  rl.close();
+
+  setCodexHooksEnabled(ctx, answer.trim().toLowerCase() === "y");
+}
+
+export function ensureCodexHooks(ctx, archiveDirName) {
+  if (!ctx.codexHooksEnabled) {
+    return;
+  }
+
+  ensureCodexHookManifestPaths(ctx);
+  for (const relativePath of ctx.optionalCodexHookPaths) {
+    replaceHarnessFile(ctx, relativePath, archiveDirName);
+  }
+}
+
+export function ensureCodexHookManifestPaths(ctx) {
+  for (const relativePath of CODEX_HOOK_MACHINE_PATHS) {
+    appendUnique(ctx.machineOwnedPaths, relativePath);
+    appendUnique(ctx.localOnlyMachineOwnedPaths, relativePath);
+    appendUnique(ctx.localOnlyGitExcludeEntries, relativePath);
+    appendUnique(ctx.localOnlyGitUntrackPaths, relativePath);
+  }
+  for (const relativePath of CODEX_HOOK_EXECUTABLE_PATHS) {
+    ctx.executableMachineOwnedPaths.add(relativePath);
+  }
+}
+
+function setCodexHooksEnabled(ctx, enabled) {
+  ctx.codexHooksEnabled = enabled;
+  if (enabled) {
+    ensureCodexHookManifestPaths(ctx);
+  }
+}
+
+function hasManagedCodexHooks(ctx) {
+  const hookConfigPath = join(ctx.targetRoot, HOOK_CONFIG_PATH);
+  if (!existsSync(hookConfigPath)) {
+    return false;
+  }
+
+  try {
+    const hooks = JSON.parse(readFileSync(hookConfigPath, "utf8"));
+    return hooks.schema === "naome.codex-hooks.v1";
+  } catch {
+    return false;
+  }
+}
+
+function parseCodexHooksOverride(value) {
+  if (value === undefined) {
+    return null;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "n", "off"].includes(normalized)) {
+    return false;
+  }
+  return null;
+}
+
+function appendUnique(values, value) {
+  if (!values.includes(value)) {
+    values.push(value);
+  }
+}

package/installer/context.js

@@ -34,6 +34,16 @@ export function createInstallerContext() {
     installPlan: null,
     machineOwnedPaths: [],
     projectOwnedPaths: [],
+    optionalCodexHookPaths: [
+      ".codex/config.toml",
+      ".codex/hooks.json",
+      ".naome/bin/codex-hook.js",
+      ".naome/bin/codex-hook-io.js",
+      ".naome/bin/codex-hook-policy.js",
+      ".naome/bin/codex-hook-runtime.js",
+      "docs/naome/codex-hooks.md",
+    ],
+    codexHooksEnabled: false,
     localOnlyMachineOwnedPaths: [],
     localOnlyGitIgnoreEntries: [],
     localOnlyGitExcludeEntries: [],