create-agdf 0.14.2 → 0.14.4

package/lib/delivery-path-search/state-adapter.js

@@ -1,11 +1,10 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 import {
   CONTRACT_VERSION,
   GENERATOR_CONTRACT_VERSION,
   validateGeneratorRequest,
 } from "./contracts.js";
-import { resolveRuns, verifyLegacyProjection } from "../control-state/index.js";
+import { evaluateGateCheck } from "../control-evaluation/gate-check.js";
+import { readRunState } from "../control-evaluation/run-state.js";
 
 function section(content, heading) {
   return (
@@ -15,100 +14,44 @@ function section(content, heading) {
   );
 }
 
-function tableAnswers(content) {
-  const answers = {};
-  for (const line of section(content, "Current Control State").split(/\r?\n/)) {
-    const cells = line
-      .split("|")
-      .slice(1, -1)
-      .map((cell) => cell.trim());
-    if (
-      cells.length >= 2 &&
-      cells[0] &&
-      !cells[0].startsWith("---") &&
-      cells[0] !== "Question"
-    )
-      answers[cells[0]] = cells[1];
-  }
-  return answers;
-}
-
-function statusCard(content) {
-  const card = {};
-  for (const line of section(content, "Run Status Card").split(/\r?\n/)) {
-    const cells = line
-      .split("|")
-      .slice(1, -1)
-      .map((cell) => cell.trim().replace(/^`|`$/g, ""));
-    if (
-      cells.length >= 2 &&
-      cells[0] &&
-      !cells[0].startsWith("---") &&
-      cells[0] !== "Run status"
-    )
-      card[cells[0]] = cells[1];
-  }
-  return card;
+function metaField(content, name) {
+  return content.match(new RegExp(`^- ${name}:\\s*(.+)$`, "m"))?.[1]
+    ?.replace(/^`|`$/g, "")
+    .trim() ?? "";
 }
 
-function listCell(value) {
-  return String(value ?? "")
-    .split(/\s*;\s*/)
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-export function searchInputFromControl(targetDir, options = {}) {
-  const canonicalRoot = join(targetDir, ".agdf", "control", "runs");
-  if (existsSync(canonicalRoot)) {
-    const projection = verifyLegacyProjection(targetDir);
-    if (!["absent", "valid"].includes(projection.status)) {
-      throw new Error(`AGDF_LEGACY_PROJECTION_DRIFT:${projection.status}`);
-    }
+export function searchInputFromControl(targetDir, options = {}, dependencies = {}) {
+  const evaluate = dependencies.evaluateGateCheck ?? evaluateGateCheck;
+  const readRun = dependencies.readRunState ?? readRunState;
+  const selection = options.scopeKey ? { runId: options.scopeKey } : {};
+  const gate = evaluate(targetDir, selection);
+  const run = readRun(targetDir, selection);
+  const content = run.content ?? "";
+  const evaluatedRunId = gate.status_card?.run_id ?? "";
+  const evaluatedRevision = gate.status_presentation?.revision_id ?? "";
+  const runId = metaField(content, "run_id");
+  const runRevision = metaField(content, "revision_id");
+  const runGate = metaField(content, "current_gate");
+  let inputFailureCode = "";
+  if (!content || run.resolution_error) inputFailureCode = "canonical_control_unavailable";
+  else if (!evaluatedRunId || !evaluatedRevision) inputFailureCode = "canonical_snapshot_identity_missing";
+  else if (evaluatedRunId !== runId || evaluatedRevision !== runRevision || gate.current_gate !== runGate) {
+    inputFailureCode = "stale_control_snapshot";
+  } else if (!Array.isArray(gate.allowed) || gate.allowed.length === 0) {
+    inputFailureCode = "canonical_actions_unavailable";
   }
-  const resolved = existsSync(canonicalRoot)
-    ? resolveRuns(targetDir, {
-        runIdArg: options.scopeKey,
-        runIdEnv: process.env.AGDF_RUN_ID,
-      })
-    : null;
-  const runPath =
-    resolved?.run.path ?? join(targetDir, ".agdf", "control", "AGDF_RUN.md");
-  if (!existsSync(runPath)) throw new Error("missing AGDF run state");
-  const content = readFileSync(runPath, "utf8");
-  const meta = Object.fromEntries(
-    [...content.matchAll(/^- ([a-z_]+):\s*(.+)$/gm)].map((match) => [
-      match[1],
-      match[2].replace(/^`|`$/g, "").trim(),
-    ]),
-  );
-  const answers = tableAnswers(content);
-  const card = statusCard(content);
   const result = {
     contract_version: CONTRACT_VERSION,
-    scope_key: options.scopeKey ?? meta.run_id ?? "unknown-scope",
-    objective: section(content, "Objective").trim(),
-    current_gate: card["Current gate"] ?? meta.current_gate ?? "unknown",
-    allowed_actions: options.allowedActions ?? listCell(card["Allowed now"]),
-    forbidden_actions:
-      options.forbiddenActions ??
-      listCell(answers["What is explicitly forbidden right now?"]),
-    evidence_refs: [
-      ...content.matchAll(
-        /\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*(direct|indirect)\s*\|/g,
-      ),
-    ]
-      .slice(1)
-      .map((match) => `${match[1].trim()}: ${match[2].trim()}`),
-    risks: section(content, "Risks")
-      .split(/\r?\n/)
-      .filter(
-        (line) =>
-          line.startsWith("|") &&
-          !line.includes("---") &&
-          !line.includes("| Risk |"),
-      )
-      .map((line) => line.split("|")[1].trim()),
+    scope_key: evaluatedRunId || runId || options.scopeKey || "unknown-scope",
+    scope_revision: evaluatedRevision || runRevision || "unversioned",
+    objective: section(content, "Objective").trim() || "Canonical Delivery Path Search input unavailable",
+    current_gate: gate.current_gate || runGate || "unknown",
+    allowed_actions: inputFailureCode ? [] : [...gate.allowed],
+    forbidden_actions: Array.isArray(gate.forbidden) ? [...gate.forbidden] : [],
+    evidence_refs: Array.isArray(gate.evidence_refs)
+      ? gate.evidence_refs.map((item) => `${item.evidence}: ${item.source}`)
+      : [],
+    risks: Array.isArray(run.risks) ? run.risks.map((item) => item.risk).filter(Boolean) : [],
     enforcement: options.enforcement ?? {
       level: "instruction_only",
       evidence: ["surface instruction prohibits implementation during search"],
@@ -122,6 +65,11 @@ export function searchInputFromControl(targetDir, options = {}) {
       stability_window: options.stabilityWindow ?? 3,
     },
   };
+  if (inputFailureCode) {
+    result.input_failure_code = inputFailureCode;
+    result.input_failure_detail = run.resolution_error || (gate.blocking_reason !== "none" ? gate.blocking_reason : "") || "canonical input is not ready";
+    result.input_recovery_action = gate.next_allowed_action || "Run canonical AGDF gate-check and repair the selected control state.";
+  }
   if (options.generation?.enabled)
     result.generation = {
       enabled: true,

package/lib/installers/claude-cache-recovery.js

@@ -0,0 +1,76 @@
+import { existsSync, lstatSync, realpathSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { win32 } from "node:path";
+import process from "node:process";
+
+function result(status, reason, removedPath = null, evidence = []) {
+  return Object.freeze({ status, reason, removed_path: removedPath, evidence });
+}
+
+function normalized(path) {
+  return win32.resolve(path).toLowerCase();
+}
+
+function parseRenameOperands(text) {
+  const matches = [...text.matchAll(/\brename\s+['"]([^'"]+)['"]\s*->\s*['"]([^'"]+)['"]/gi)];
+  return matches.length === 1 ? matches[0].slice(1, 3) : null;
+}
+
+export function recoverClaudeCacheTemp({
+  error,
+  expectedVersion,
+  platform = process.platform,
+  env = process.env,
+  home = homedir(),
+  fs = { existsSync, lstatSync, realpathSync, rmSync },
+} = {}) {
+  const text = String(error?.message ?? error ?? "");
+  if (platform !== "win32" || !/\bEPERM\b/i.test(text) || !/\brename\b/i.test(text)) {
+    return result("not_applicable", "claude_cache_temp_recovery_not_applicable");
+  }
+  const operands = parseRenameOperands(text);
+  if (!operands || typeof expectedVersion !== "string" || !/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(expectedVersion)) {
+    return result("unsafe", "claude_cache_temp_recovery_unsafe");
+  }
+  const configRoot = win32.resolve(env.CLAUDE_CONFIG_DIR || win32.join(home, ".claude"));
+  const namespace = win32.join(configRoot, "plugins", "cache", "agdf", "agdf");
+  const absoluteOperands = operands.filter((path) => win32.isAbsolute(path));
+  if (absoluteOperands.length !== 2
+      || absoluteOperands.some((path) => normalized(win32.dirname(path)) !== normalized(namespace))) {
+    return result("unsafe", "claude_cache_temp_recovery_unsafe");
+  }
+  const [candidate, destination] = absoluteOperands;
+  if (!/^temp_local_[0-9A-Za-z._-]+$/.test(win32.basename(candidate))
+      || !fs.existsSync(candidate)) {
+    return result("unsafe", "claude_cache_temp_recovery_unsafe");
+  }
+  if (win32.basename(destination) !== expectedVersion || fs.existsSync(destination)) {
+    return result("unsafe", "claude_cache_temp_recovery_unsafe");
+  }
+  let candidateStats;
+  let realNamespace;
+  let realCandidate;
+  try {
+    candidateStats = fs.lstatSync(candidate);
+    realNamespace = fs.realpathSync(namespace);
+    realCandidate = fs.realpathSync(candidate);
+  } catch {
+    return result("unsafe", "claude_cache_temp_recovery_unsafe");
+  }
+  if (!candidateStats.isDirectory() || candidateStats.isSymbolicLink()
+      || normalized(win32.dirname(realCandidate)) !== normalized(realNamespace)
+      || normalized(realCandidate) !== normalized(candidate)) {
+    return result("unsafe", "claude_cache_temp_recovery_unsafe");
+  }
+  try {
+    fs.rmSync(candidate, { recursive: true, force: false });
+  } catch {
+    return result("unsafe", "claude_cache_temp_recovery_unsafe");
+  }
+  return result(
+    "recovered",
+    "claude_cache_temp_recovery_bounded_retry",
+    candidate,
+    [`cache_entry:${win32.basename(candidate)}`, `target_version:${expectedVersion}`],
+  );
+}

package/lib/installers/copilot-settings.js

@@ -1,49 +1,179 @@
+import { execFileSync } from "node:child_process";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import process from "node:process";
 import { renameSyncWithRetry } from "../fs-swap.js";
 
+const COPILOT_PLUGIN_SELECTOR = "agdf@agdf";
+const COPILOT_LOCAL_SETTINGS = join(".github", "copilot", "settings.local.json");
+const COPILOT_SHARED_SETTINGS = join(".github", "copilot", "settings.json");
+
 export function defaultCopilotSettingsPath({ env = process.env, home = homedir() } = {}) {
   return join(resolve(env.COPILOT_HOME || join(home, ".copilot")), "settings.json");
 }
 
 export function readCopilotSettings(path = defaultCopilotSettingsPath()) {
-  if (!existsSync(path)) return { exists: false, settings: {} };
+  if (!existsSync(path)) return { exists: false, settings: {}, content: null };
   const stats = lstatSync(path);
   if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("AGDF_COPILOT_SETTINGS_UNOWNED_PATH");
   try {
-    const settings = JSON.parse(readFileSync(path, "utf8"));
+    const content = readFileSync(path, "utf8");
+    const settings = JSON.parse(content);
     if (!settings || typeof settings !== "object" || Array.isArray(settings)) throw new Error("not an object");
     if (settings.enabledPlugins !== undefined
         && (!settings.enabledPlugins || typeof settings.enabledPlugins !== "object" || Array.isArray(settings.enabledPlugins))) {
       throw new Error("enabledPlugins must be an object");
     }
-    return { exists: true, settings };
+    return { exists: true, settings, content };
   } catch (error) {
     throw new Error(`AGDF_COPILOT_SETTINGS_INVALID: ${error.message}`);
   }
 }
 
-function atomicSettingsWrite(path, settings) {
-  mkdirSync(dirname(path), { recursive: true });
+function atomicContentWrite(path, content, dependencies = {}) {
+  const makeDirectory = dependencies.mkdir ?? mkdirSync;
+  const write = dependencies.write ?? writeFileSync;
+  const rename = dependencies.rename ?? renameSyncWithRetry;
+  const remove = dependencies.remove ?? rmSync;
+  const changeMode = dependencies.chmod ?? chmodSync;
+  const exists = dependencies.exists ?? existsSync;
+  const stat = dependencies.lstat ?? lstatSync;
+  makeDirectory(dirname(path), { recursive: true });
   const temp = `${path}.agdf-tmp-${process.pid}`;
   const backup = `${path}.agdf-backup-${process.pid}`;
-  const hadPrevious = existsSync(path);
-  const mode = hadPrevious ? lstatSync(path).mode & 0o777 : 0o600;
-  writeFileSync(temp, `${JSON.stringify(settings, null, 2)}\n`, { encoding: "utf8", flag: "wx", mode });
-  if (process.platform !== "win32") chmodSync(temp, mode);
+  const hadPrevious = exists(path);
+  const mode = hadPrevious ? stat(path).mode & 0o777 : 0o600;
+  write(temp, content, { encoding: "utf8", flag: "wx", mode });
+  if (process.platform !== "win32") changeMode(temp, mode);
   try {
-    if (hadPrevious && process.platform === "win32") renameSyncWithRetry(path, backup);
-    renameSyncWithRetry(temp, path);
-    if (hadPrevious && process.platform === "win32") rmSync(backup, { force: true });
+    if (hadPrevious && process.platform === "win32") rename(path, backup);
+    rename(temp, path);
+    if (hadPrevious && process.platform === "win32") remove(backup, { force: true });
   } catch (error) {
-    try { rmSync(temp, { force: true }); } catch {}
-    if (hadPrevious && process.platform === "win32" && existsSync(backup) && !existsSync(path)) renameSyncWithRetry(backup, path);
+    try { remove(temp, { force: true }); } catch {}
+    if (hadPrevious && process.platform === "win32" && exists(backup) && !exists(path)) rename(backup, path);
     throw error;
   }
 }
 
+export function atomicSettingsWrite(path, settings, dependencies = {}) {
+  atomicContentWrite(path, `${JSON.stringify(settings, null, 2)}\n`, dependencies);
+}
+
+export function repositoryCopilotSettingsPath(targetDir, { shared = false } = {}) {
+  const root = resolve(targetDir);
+  if (!existsSync(root) || lstatSync(root).isSymbolicLink() || !lstatSync(root).isDirectory()) {
+    throw new Error(`AGDF_COPILOT_REPOSITORY_UNOWNED_PATH: ${root}`);
+  }
+  const path = resolve(root, shared ? COPILOT_SHARED_SETTINGS : COPILOT_LOCAL_SETTINGS);
+  const fromRoot = relative(root, path);
+  if (!fromRoot || fromRoot.startsWith("..") || isAbsolute(fromRoot)) {
+    throw new Error("AGDF_COPILOT_REPOSITORY_SETTINGS_OUTSIDE_ROOT");
+  }
+  for (const candidate of [root, join(root, ".github"), join(root, ".github", "copilot")]) {
+    if (existsSync(candidate) && lstatSync(candidate).isSymbolicLink()) {
+      throw new Error(`AGDF_COPILOT_SETTINGS_UNOWNED_PATH: ${candidate}`);
+    }
+    if (existsSync(candidate) && !lstatSync(candidate).isDirectory()) {
+      throw new Error(`AGDF_COPILOT_SETTINGS_UNOWNED_PATH: ${candidate}`);
+    }
+  }
+  if (existsSync(path) && (lstatSync(path).isSymbolicLink() || !lstatSync(path).isFile())) {
+    throw new Error(`AGDF_COPILOT_SETTINGS_UNOWNED_PATH: ${path}`);
+  }
+  return path;
+}
+
+export function assertCopilotLocalSettingsIgnored(targetDir, { exec = execFileSync } = {}) {
+  const root = resolve(targetDir);
+  try {
+    exec("git", ["check-ignore", "--quiet", "--", COPILOT_LOCAL_SETTINGS], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      throw new Error("AGDF_COPILOT_GIT_UNAVAILABLE: install Git and retry personal disable, or use --shared deliberately.");
+    }
+    if (error?.status === 1) {
+      throw new Error(`AGDF_COPILOT_LOCAL_SETTINGS_NOT_IGNORED: add ${COPILOT_LOCAL_SETTINGS} to an effective Git ignore source and retry, or use --shared deliberately.`);
+    }
+    throw new Error(`AGDF_COPILOT_GIT_IGNORE_UNVERIFIED: ${error?.message || "Git could not verify the repository ignore state."}`);
+  }
+  return { status: "ignored", path: COPILOT_LOCAL_SETTINGS };
+}
+
+export function planCopilotRepositoryDisable({ targetDir, shared = false, exec = execFileSync }) {
+  const root = resolve(targetDir);
+  const path = repositoryCopilotSettingsPath(root, { shared });
+  if (!shared) assertCopilotLocalSettingsIgnored(root, { exec });
+  const before = readCopilotSettings(path);
+  const current = before.settings.enabledPlugins?.[COPILOT_PLUGIN_SELECTOR];
+  if (current !== undefined && typeof current !== "boolean") {
+    throw new Error(`AGDF_COPILOT_SETTINGS_AMBIGUOUS_PLUGIN_STATE: ${path}`);
+  }
+  const next = structuredClone(before.settings);
+  next.enabledPlugins = { ...(next.enabledPlugins ?? {}), [COPILOT_PLUGIN_SELECTOR]: false };
+  return Object.freeze({
+    path,
+    root,
+    shared,
+    audience: shared ? "shared" : "personal",
+    selector: COPILOT_PLUGIN_SELECTOR,
+    before: Object.freeze({ exists: before.exists, settings: structuredClone(before.settings), content: before.content }),
+    settings: Object.freeze(next),
+    changed: current !== false,
+  });
+}
+
+export function applyCopilotRepositoryDisable(mutation, dependencies = {}) {
+  if (!mutation?.path || mutation.selector !== COPILOT_PLUGIN_SELECTOR || mutation.settings?.enabledPlugins?.[COPILOT_PLUGIN_SELECTOR] !== false) {
+    throw new Error("AGDF_COPILOT_SETTINGS_MUTATION_INVALID");
+  }
+  const read = dependencies.read ?? readCopilotSettings;
+  const write = dependencies.writeSettings ?? ((path, settings) => atomicSettingsWrite(path, settings, dependencies));
+  const writeContent = dependencies.writeContent ?? ((path, content) => atomicContentWrite(path, content, dependencies));
+  const remove = dependencies.remove ?? rmSync;
+  const resolvedPath = repositoryCopilotSettingsPath(mutation.root, { shared: mutation.shared });
+  if (resolvedPath !== mutation.path) throw new Error("AGDF_COPILOT_SETTINGS_MUTATION_PATH_MISMATCH");
+  const current = read(mutation.path);
+  if (current.exists !== mutation.before.exists || (current.exists && current.content !== mutation.before.content)) {
+    throw new Error(`AGDF_COPILOT_SETTINGS_CHANGED_DURING_APPLY: ${mutation.path}`);
+  }
+  if (!mutation.changed) return { status: "unchanged", path: mutation.path };
+  try {
+    write(mutation.path, mutation.settings);
+    const verified = read(mutation.path);
+    if (verified.settings.enabledPlugins?.[COPILOT_PLUGIN_SELECTOR] !== false) {
+      throw new Error("AGDF_COPILOT_SETTINGS_VERIFICATION_FAILED");
+    }
+    return { status: "written", path: mutation.path };
+  } catch (error) {
+    try {
+      if (mutation.before.exists) writeContent(mutation.path, mutation.before.content);
+      else remove(mutation.path, { force: true });
+    } catch (rollbackError) {
+      error.rollbackError = rollbackError;
+    }
+    throw error;
+  }
+}
+
+export function verifyCopilotRepositoryDisabled(targetDir, { shared = false } = {}) {
+  try {
+    const path = repositoryCopilotSettingsPath(targetDir, { shared });
+    if (!existsSync(path)) return { status: "failed", evidence: [`missing:${path}`] };
+    const state = readCopilotSettings(path);
+    return state.settings.enabledPlugins?.[COPILOT_PLUGIN_SELECTOR] === false
+      ? { status: "healthy", evidence: [`${path}:${COPILOT_PLUGIN_SELECTOR}:enabled=false`, `audience:${shared ? "shared" : "personal"}`] }
+      : { status: "failed", evidence: [`postcondition_failed:${path}:${COPILOT_PLUGIN_SELECTOR}`] };
+  } catch (error) {
+    return { status: "failed", evidence: [`verification_failed:${resolve(targetDir)}:${error.message}`] };
+  }
+}
+
 export function configureCopilotDeclarativePlugin({ path = defaultCopilotSettingsPath(), pluginRoot }) {
   if (typeof pluginRoot !== "string" || !pluginRoot.trim() || !isAbsolute(pluginRoot)) {
     throw new Error("AGDF_COPILOT_PLUGIN_SPEC_INVALID");
@@ -64,7 +194,7 @@ export function configureCopilotDeclarativePlugin({ path = defaultCopilotSetting
     path,
     spec,
     rollback() {
-      if (before.exists) atomicSettingsWrite(path, before.settings);
+      if (before.exists) atomicContentWrite(path, before.content);
       else rmSync(path, { force: true });
     },
   };