@luizsantiago/spec-guardrails 3.2.0 → 3.3.0

package/README.md

@@ -11,7 +11,7 @@
 | **Solution** | One kit, two deliberate modes: **Process** (Node only) for a flexible spec-driven workflow; **Brakes** (Node + Python) for the **full product** — structural gates that exit non-zero when paperwork or evidence is missing. You approve specs/tasks in both. |
 | **Result** | Traceable `.specs/` memory, fewer fake finishes, cheaper turns (~70% less skill text on planning). Choose Process for light ceremony; add Python when you want the [Guarantees matrix](#guarantees-matrix) enforced automatically. |
 
-npm: [`@luizsantiago/spec-guardrails`](https://www.npmjs.com/package/@luizsantiago/spec-guardrails) **3.2.x**
+npm: [`@luizsantiago/spec-guardrails`](https://www.npmjs.com/package/@luizsantiago/spec-guardrails) **3.3.x**
 
 ---
 
@@ -217,6 +217,7 @@ npx @luizsantiago/spec-guardrails install
 
 | Version | What you gain |
 | --- | --- |
+| **3.3.x** | Intent/effect policy — `check-path --op read|write|delete` and `effects` config block |
 | **3.2.x** | Single-package focus; artifact gate severity labels; git worktree isolation CLI; execution policy (budget/scope/escalation) |
 | **3.1.x** | Copilot/Codex/AGENTS.md adapters; doctor Process + Brakes scores; `validate-traceability` / `validate-quick`; `classify-change` / `feature-status` |
 | **3.0.x** | Final name Spec Guardrails; `.specs/guardrails/`; no dual-path ([Migration](docs/guide/Migration.md)) |

package/index.js

@@ -9,10 +9,12 @@ import { PACKAGE_VERSION, CLI_NAME } from "./lib/constants.js";
 import { phaseContext } from "./lib/config.js";
 import { doctor } from "./lib/doctor.js";
 import {
-  checkPathScope,
   formatPolicyStatus,
   loadExecutionPolicy,
   loadPolicyState,
+  recordAgentRun,
+  recordTaskRetry,
+  resolvePathCheck,
   savePolicyState,
 } from "./lib/execution-policy.js";
 import { featureInit } from "./lib/feature.js";
@@ -21,7 +23,9 @@ import { GATE_COMMANDS, AUX_COMMANDS, runGate, runGuardrailsScript } from "./lib
 import { install } from "./lib/install.js";
 import {
   cleanupWorkspaces,
+  formatWorkspaceList,
   formatWorkspaceResults,
+  listWorkspaces,
   prepareWorkspaces,
 } from "./lib/workspace-isolation.js";
 import {
@@ -70,13 +74,21 @@ Commands:
     [--json]                         Machine-readable output
   workspace-cleanup <feature>        Remove isolated worktrees for a feature
     [--tasks T1,T2]                  Limit cleanup to specific tasks
-    [--force]                        Force-remove dirty worktrees
+    [--force]                        Force-remove dirty worktrees (recovery after worker FAIL)
+    [--json]                         Machine-readable output
+  workspace-list <feature>           List isolated worktrees for a feature
     [--json]                         Machine-readable output
   execution-policy status            Show configured budgets, scope, and runtime counters
     [--json]                         Machine-readable output
   execution-policy check-path <path> Check whether a relative path is allowed by scope policy
+    [--op read|write|delete]         Intended operation (default: inferred from path)
+    [--json]                         Machine-readable output
+  execution-policy record-retry <task>  Increment retry counter for a task id (blocks at limit)
+  execution-policy record-run        Increment agent-run counter (blocks at budget)
+  memory-index rebuild               Rebuild SQLite memory index from .specs/ artifacts
+  memory-query --from <id>           Bounded context package from the knowledge graph
+    [--depth N]                      Traversal depth (default 2)
     [--json]                         Machine-readable output
-  execution-policy record-retry <task>  Increment retry counter for a task id
   validate-spec [spec.md|feature]    Closure gate for a feature spec
   analyze-artifacts [feature]        Cross-artifact consistency before task approval
   validate-tasks [tasks.md|feature]  Granularity gate for a task breakdown
@@ -86,7 +98,7 @@ Commands:
   validate-quick [quick-folder]      Quick-mode TASK.md / SUMMARY.md structural gate
   validate-state [feature]           Completion gate before declaring a feature done
   check-commit --message "<msg>"     Conventional Commits gate
-  lessons <add|list|penalize|prune|status>  Lessons engine
+  lessons <add|list|penalize|prune|promote|graduate|status>  Lessons engine
   --help                             Show this message
   --version                          Print the package version
 `;
@@ -426,6 +438,30 @@ if (command === "--version" || command === "-v" || command === "version") {
     console.error(`❌ ${err.message}`);
     process.exit(1);
   }
+} else if (command === "workspace-list") {
+  try {
+    let json = false;
+    const positional = [];
+
+    for (const arg of args) {
+      if (arg === "--json") {
+        json = true;
+      } else {
+        positional.push(arg);
+      }
+    }
+
+    const featureId = positional[0];
+    if (!featureId) {
+      throw new Error("Usage: workspace-list <feature> [--json]");
+    }
+
+    const workspaces = await listWorkspaces(process.cwd(), featureId);
+    process.stdout.write(formatWorkspaceList(workspaces, { json, featureId }));
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
 } else if (command === "execution-policy") {
   try {
     const sub = args[0];
@@ -447,37 +483,82 @@ if (command === "--version" || command === "-v" || command === "version") {
     if (sub === "status") {
       process.stdout.write(formatPolicyStatus(policy, state, { json }));
     } else if (sub === "check-path") {
-      const relativePath = rest[0];
+      let operation;
+      const positional = [];
+
+      for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === "--op") {
+          operation = rest[++i];
+          if (!operation) {
+            throw new Error("--op requires read, write, or delete");
+          }
+        } else {
+          positional.push(arg);
+        }
+      }
+
+      const relativePath = positional[0];
       if (!relativePath) {
-        throw new Error("Usage: execution-policy check-path <relative-path>");
+        throw new Error(
+          "Usage: execution-policy check-path <relative-path> [--op read|write|delete]",
+        );
       }
-      const result = checkPathScope(relativePath, policy);
+      const result = resolvePathCheck(relativePath, policy, { operation });
       if (json) {
         console.log(JSON.stringify({ path: relativePath, ...result }, null, 2));
       } else {
+        const label = result.allowed
+          ? result.severity === "warning"
+            ? "allowed (warn)"
+            : "allowed"
+          : result.severity === "warning"
+            ? "blocked (warn)"
+            : "blocked";
         console.log(
-          `${relativePath}: ${result.allowed ? "allowed" : "blocked"} (${result.reason})`,
+          `${relativePath} [${result.operation}]: ${label} (${result.reason})`,
         );
       }
-      if (!result.allowed) {
-        process.exit(1);
+      if (result.exitCode !== 0) {
+        process.exit(result.exitCode);
       }
     } else if (sub === "record-retry") {
       const taskId = rest[0];
       if (!taskId) {
         throw new Error("Usage: execution-policy record-retry <task-id>");
       }
-      state.retries[taskId] = (state.retries[taskId] ?? 0) + 1;
-      state.iterations += 1;
-      await savePolicyState(cwd, state);
+      const recorded = recordTaskRetry(state, taskId, policy);
+      if (!recorded.ok) {
+        console.error(`❌ ${recorded.message}`);
+        process.exit(1);
+      }
+      await savePolicyState(cwd, recorded.state);
+      if (json) {
+        console.log(
+          JSON.stringify({ taskId, retries: recorded.retries, state: recorded.state }, null, 2),
+        );
+      } else {
+        console.log(`Recorded retry for ${taskId}: ${recorded.retries}`);
+      }
+    } else if (sub === "record-run") {
+      const recorded = recordAgentRun(state, policy);
+      if (!recorded.ok) {
+        console.error(`❌ ${recorded.message}`);
+        process.exit(1);
+      }
+      await savePolicyState(cwd, recorded.state);
       if (json) {
-        console.log(JSON.stringify({ taskId, retries: state.retries[taskId], state }, null, 2));
+        console.log(
+          JSON.stringify({ agent_runs: recorded.state.agent_runs, state: recorded.state }, null, 2),
+        );
       } else {
-        console.log(`Recorded retry for ${taskId}: ${state.retries[taskId]}`);
+        console.log(
+          `Recorded agent run: ${recorded.state.agent_runs}/${policy.budget.max_agent_runs}`,
+        );
       }
     } else {
       throw new Error(
-        "Usage: execution-policy status | check-path <path> | record-retry <task>",
+        "Usage: execution-policy status | check-path <path> | record-retry <task> | record-run",
       );
     }
   } catch (err) {
@@ -536,7 +617,8 @@ if (command === "--version" || command === "-v" || command === "version") {
     console.error(`❌ ${err.message}`);
     process.exit(1);
   }
-} else if (AUX_COMMANDS.includes(command)) {  try {
+} else if (AUX_COMMANDS.includes(command)) {
+  try {
     const code = await runGuardrailsScript(command, args);
     process.exit(code);
   } catch (err) {

package/lib/adapter-registry.js

@@ -0,0 +1,128 @@
+import { injectAgentsMd } from "./agents-md.js";
+import { injectCodexAgents } from "./codex-agents.js";
+import { injectCopilotInstructions } from "./copilot-instructions.js";
+import { injectClaudeMd } from "./claude-md.js";
+import { injectCursorRules } from "./cursorrules.js";
+
+/**
+ * @typedef {{
+ *   id: string,
+ *   label: string,
+ *   skillsDir: string | null,
+ *   entryFiles: string[],
+ *   capabilities: {
+ *     supports_hooks: boolean,
+ *     supports_commands: boolean,
+ *     supports_rules: boolean,
+ *     supports_skills: boolean,
+ *   },
+ *   install: (cwd: string) => Promise<void>,
+ * }} PlatformAdapter
+ */
+
+/** @type {PlatformAdapter[]} */
+export const ADAPTER_REGISTRY = [
+  {
+    id: "cursor",
+    label: "Cursor",
+    skillsDir: ".cursor/skills",
+    entryFiles: [".cursorrules", ".cursor/rules/engineering-baseline.mdc"],
+    capabilities: {
+      supports_hooks: true,
+      supports_commands: true,
+      supports_rules: true,
+      supports_skills: true,
+    },
+    install: injectCursorRules,
+  },
+  {
+    id: "claude",
+    label: "Claude Code",
+    skillsDir: ".claude/skills",
+    entryFiles: [".claude/CLAUDE.md"],
+    capabilities: {
+      supports_hooks: false,
+      supports_commands: true,
+      supports_rules: false,
+      supports_skills: true,
+    },
+    install: injectClaudeMd,
+  },
+  {
+    id: "copilot",
+    label: "GitHub Copilot",
+    skillsDir: ".github/skills",
+    entryFiles: [".github/copilot-instructions.md"],
+    capabilities: {
+      supports_hooks: false,
+      supports_commands: false,
+      supports_rules: false,
+      supports_skills: true,
+    },
+    install: injectCopilotInstructions,
+  },
+  {
+    id: "codex",
+    label: "OpenAI Codex",
+    skillsDir: ".codex/skills",
+    entryFiles: [".codex/AGENTS.md"],
+    capabilities: {
+      supports_hooks: false,
+      supports_commands: false,
+      supports_rules: false,
+      supports_skills: true,
+    },
+    install: injectCodexAgents,
+  },
+  {
+    id: "agents-md",
+    label: "AGENTS.md (open standard)",
+    skillsDir: null,
+    entryFiles: ["AGENTS.md"],
+    capabilities: {
+      supports_hooks: false,
+      supports_commands: false,
+      supports_rules: false,
+      supports_skills: false,
+    },
+    install: injectAgentsMd,
+  },
+];
+
+/**
+ * @param {string} id
+ * @returns {PlatformAdapter | undefined}
+ */
+export function getAdapter(id) {
+  return ADAPTER_REGISTRY.find((adapter) => adapter.id === id);
+}
+
+/** @returns {PlatformAdapter[]} */
+export function listAdapters() {
+  return [...ADAPTER_REGISTRY];
+}
+
+/**
+ * @param {keyof PlatformAdapter["capabilities"]} capability
+ * @returns {PlatformAdapter[]}
+ */
+export function getAdaptersWithCapability(capability) {
+  return ADAPTER_REGISTRY.filter((adapter) => adapter.capabilities[capability]);
+}
+
+/**
+ * @param {string} cwd
+ * @param {PlatformAdapter} [adapter]
+ */
+export async function installAdapter(cwd, adapter) {
+  await adapter.install(cwd);
+}
+
+/**
+ * Install all registered platform adapters.
+ *
+ * @param {string} cwd
+ */
+export async function installAllAdapters(cwd) {
+  await Promise.all(ADAPTER_REGISTRY.map((adapter) => installAdapter(cwd, adapter)));
+}

package/lib/adapters.js

@@ -1,17 +1,11 @@
-import { injectAgentsMd } from "./agents-md.js";
-import { injectCodexAgents } from "./codex-agents.js";
-import { injectCopilotInstructions } from "./copilot-instructions.js";
+import { installAllAdapters } from "./adapter-registry.js";
 
 /**
  * Install shipped platform adapter entry files (Copilot, Codex, AGENTS.md).
- * Cursor and Claude adapters are injected separately in install.js.
+ * Cursor and Claude adapters are injected via the same registry during install.
  *
  * @param {string} cwd
  */
 export async function installPlatformAdapters(cwd) {
-  return Promise.all([
-    injectCopilotInstructions(cwd),
-    injectAgentsMd(cwd),
-    injectCodexAgents(cwd),
-  ]);
+  return installAllAdapters(cwd);
 }

package/lib/constants.js

@@ -108,6 +108,8 @@ export const SCRIPT_ASSETS = [
   { file: "check_commit.py", remotePath: "scripts/check_commit.py" },
   { file: "lessons.py", remotePath: "scripts/lessons.py" },
   { file: "loop_plan.py", remotePath: "scripts/loop_plan.py" },
+  { file: "memory_index.py", remotePath: "scripts/memory_index.py" },
+  { file: "memory_query.py", remotePath: "scripts/memory_query.py" },
 ];
 
 /** @type {{ file: string, remotePath: string }[]} */

package/lib/execution-policy.js

@@ -21,6 +21,14 @@ export const DEFAULT_POLICY = {
     on_budget_exhaustion: "stop",
     on_policy_violation: "block",
   },
+  effects: {
+    deny_read: [],
+    deny_write: [],
+    deny_delete: ["**/.git/**"],
+    warn_read: [],
+    warn_write: [],
+    warn_delete: [],
+  },
 };
 
 /**
@@ -28,9 +36,15 @@ export const DEFAULT_POLICY = {
  *   budget: { max_iterations: number, max_agent_runs: number, max_retries_per_task: number },
  *   scope: { allowed_paths: string[], denied_paths: string[] },
  *   escalation: { on_scope_expansion: string, on_budget_exhaustion: string, on_policy_violation: string },
+ *   effects: {
+ *     deny_read: string[], deny_write: string[], deny_delete: string[],
+ *     warn_read: string[], warn_write: string[], warn_delete: string[],
+ *   },
  * }} ExecutionPolicy
  */
 
+/** @typedef {"read" | "write" | "delete"} PathOperation */
+
 /**
  * @typedef {{
  *   iterations: number,
@@ -48,7 +62,7 @@ export const DEFAULT_POLICY = {
 export function parseExecutionPolicySections(text) {
   /** @type {Partial<ExecutionPolicy>} */
   const result = {};
-  /** @type {"budget" | "scope" | "escalation" | null} */
+  /** @type {"budget" | "scope" | "escalation" | "effects" | null} */
   let section = null;
   /** @type {string | null} */
   let listKey = null;
@@ -59,9 +73,9 @@ export function parseExecutionPolicySections(text) {
       continue;
     }
 
-    const sectionMatch = trimmed.match(/^(budget|scope|escalation):\s*$/);
+    const sectionMatch = trimmed.match(/^(budget|scope|escalation|effects):\s*$/);
     if (sectionMatch) {
-      section = /** @type {"budget" | "scope" | "escalation"} */ (sectionMatch[1]);
+      section = /** @type {"budget" | "scope" | "escalation" | "effects"} */ (sectionMatch[1]);
       result[section] = result[section] ?? {};
       listKey = null;
       continue;
@@ -112,6 +126,14 @@ export function mergeExecutionPolicy(base, overlay) {
       denied_paths: overlay.scope?.denied_paths ?? base.scope.denied_paths,
     },
     escalation: { ...base.escalation, ...(overlay.escalation ?? {}) },
+    effects: {
+      deny_read: overlay.effects?.deny_read ?? base.effects.deny_read,
+      deny_write: overlay.effects?.deny_write ?? base.effects.deny_write,
+      deny_delete: overlay.effects?.deny_delete ?? base.effects.deny_delete,
+      warn_read: overlay.effects?.warn_read ?? base.effects.warn_read,
+      warn_write: overlay.effects?.warn_write ?? base.effects.warn_write,
+      warn_delete: overlay.effects?.warn_delete ?? base.effects.warn_delete,
+    },
   };
 }
 
@@ -191,6 +213,154 @@ export function checkPathScope(relativePath, policy) {
   };
 }
 
+const PATH_OPERATIONS = new Set(["read", "write", "delete"]);
+
+/**
+ * @param {string | undefined | null} raw
+ * @returns {PathOperation}
+ */
+export function normalizePathOperation(raw) {
+  const value = String(raw ?? "write").trim().toLowerCase();
+  if (!PATH_OPERATIONS.has(value)) {
+    throw new Error(`unknown operation '${raw}' — use read, write, or delete`);
+  }
+  return /** @type {PathOperation} */ (value);
+}
+
+/**
+ * Heuristic intent when the agent did not declare an operation explicitly.
+ *
+ * @param {string} relativePath
+ * @returns {PathOperation}
+ */
+export function inferPathOperation(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  const readOnly = /\.(md|txt|json|yaml|yml|lock)$/i.test(normalized);
+  return readOnly ? "read" : "write";
+}
+
+/**
+ * @param {PathOperation} operation
+ * @param {ExecutionPolicy["effects"]} effects
+ * @returns {{ deny: string[], warn: string[] }}
+ */
+export function effectRulesForOperation(operation, effects) {
+  return {
+    deny: effects[`deny_${operation}`] ?? [],
+    warn: effects[`warn_${operation}`] ?? [],
+  };
+}
+
+/**
+ * @param {string} relativePath
+ * @param {PathOperation} operation
+ * @param {ExecutionPolicy} policy
+ * @returns {{ allowed: boolean, severity: "blocking" | "warning" | "info", reason: string, operation: PathOperation }}
+ */
+export function checkPathEffect(relativePath, operation, policy) {
+  const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  const { deny, warn } = effectRulesForOperation(operation, policy.effects);
+
+  for (const pattern of deny) {
+    if (matchGlobPattern(pattern, normalized)) {
+      return {
+        allowed: false,
+        severity: "blocking",
+        reason: `${operation.toUpperCase()} denied for path matching ${pattern}`,
+        operation,
+      };
+    }
+  }
+
+  for (const pattern of warn) {
+    if (matchGlobPattern(pattern, normalized)) {
+      return {
+        allowed: true,
+        severity: "warning",
+        reason: `${operation.toUpperCase()} warned for path matching ${pattern}`,
+        operation,
+      };
+    }
+  }
+
+  return {
+    allowed: true,
+    severity: "info",
+    reason: `no ${operation} effect rules matched`,
+    operation,
+  };
+}
+
+/**
+ * @param {string} relativePath
+ * @param {ExecutionPolicy} policy
+ * @param {{ operation?: string | null }} [options]
+ * @returns {{
+ *   allowed: boolean,
+ *   exitCode: number,
+ *   severity: "blocking" | "warning" | "info",
+ *   reason: string,
+ *   operation: PathOperation,
+ *   scope: ReturnType<typeof checkPathScope>,
+ *   effect: ReturnType<typeof checkPathEffect>,
+ * }}
+ */
+export function resolvePathCheck(relativePath, policy, options = {}) {
+  const operation = options.operation
+    ? normalizePathOperation(options.operation)
+    : inferPathOperation(relativePath);
+  const scope = checkPathScope(relativePath, policy);
+  const effect = checkPathEffect(relativePath, operation, policy);
+
+  if (!scope.allowed) {
+    const mode = policy.escalation.on_policy_violation ?? "block";
+    return {
+      allowed: false,
+      severity: mode === "warn" ? "warning" : "blocking",
+      reason: scope.reason,
+      operation,
+      scope,
+      effect,
+      exitCode: mode === "warn" ? 0 : 1,
+    };
+  }
+
+  if (!effect.allowed) {
+    const mode = policy.escalation.on_policy_violation ?? "block";
+    return {
+      allowed: false,
+      severity: mode === "warn" ? "warning" : "blocking",
+      reason: effect.reason,
+      operation,
+      scope,
+      effect,
+      exitCode: mode === "warn" ? 0 : 1,
+    };
+  }
+
+  if (effect.severity === "warning") {
+    return {
+      allowed: true,
+      severity: "warning",
+      reason: effect.reason,
+      operation,
+      scope,
+      effect,
+      exitCode: 0,
+    };
+  }
+
+  return {
+    allowed: true,
+    severity: "info",
+    reason: scope.reason,
+    operation,
+    scope,
+    effect,
+    exitCode: 0,
+  };
+}
+
 /**
  * @param {string} cwd
  * @returns {Promise<ExecutionPolicyState>}
@@ -241,7 +411,7 @@ export function checkBudget(state, policy) {
  * @param {ExecutionPolicy} policy
  * @returns {{ ok: boolean, severity?: "blocking", message?: string, retries: number }}
  */
-export function checkTaskRetries(taskId, state, policy) {
+export function previewTaskRetry(taskId, state, policy) {
   const retries = state.retries[taskId] ?? 0;
   if (retries >= policy.budget.max_retries_per_task) {
     return {
@@ -254,6 +424,70 @@ export function checkTaskRetries(taskId, state, policy) {
   return { ok: true, retries };
 }
 
+/**
+ * @param {string} taskId
+ * @param {ExecutionPolicyState} state
+ * @param {ExecutionPolicy} policy
+ * @returns {{ ok: boolean, severity?: "blocking", message?: string, retries: number }}
+ */
+export function checkTaskRetries(taskId, state, policy) {
+  const preview = previewTaskRetry(taskId, state, policy);
+  return preview.ok
+    ? { ok: true, retries: preview.retries }
+    : {
+        ok: false,
+        severity: preview.severity,
+        message: preview.message,
+        retries: preview.retries,
+      };
+}
+
+/**
+ * @param {ExecutionPolicyState} state
+ * @param {ExecutionPolicy} policy
+ * @returns {{ ok: boolean, message?: string }}
+ */
+export function previewAgentRun(state, policy) {
+  if (state.agent_runs >= policy.budget.max_agent_runs) {
+    return { ok: false, message: "max_agent_runs budget exhausted" };
+  }
+  return { ok: true };
+}
+
+/**
+ * @param {ExecutionPolicyState} state
+ * @param {string} taskId
+ * @param {ExecutionPolicy} policy
+ * @returns {{ ok: boolean, state: ExecutionPolicyState, retries: number, message?: string }}
+ */
+export function recordTaskRetry(state, taskId, policy) {
+  const preview = previewTaskRetry(taskId, state, policy);
+  if (!preview.ok) {
+    return { ok: false, state, retries: preview.retries, message: preview.message };
+  }
+
+  const next = structuredClone(state);
+  next.retries[taskId] = (next.retries[taskId] ?? 0) + 1;
+  next.iterations += 1;
+  return { ok: true, state: next, retries: next.retries[taskId] };
+}
+
+/**
+ * @param {ExecutionPolicyState} state
+ * @param {ExecutionPolicy} policy
+ * @returns {{ ok: boolean, state: ExecutionPolicyState, message?: string }}
+ */
+export function recordAgentRun(state, policy) {
+  const preview = previewAgentRun(state, policy);
+  if (!preview.ok) {
+    return { ok: false, state, message: preview.message };
+  }
+
+  const next = structuredClone(state);
+  next.agent_runs += 1;
+  return { ok: true, state: next };
+}
+
 /**
  * @param {ExecutionPolicy} policy
  * @param {ExecutionPolicyState} state
@@ -278,6 +512,7 @@ export function formatPolicyStatus(policy, state, options = {}) {
     `  agent_runs: ${state.agent_runs}/${policy.budget.max_agent_runs}`,
     `  allowed_paths: ${policy.scope.allowed_paths.length ? policy.scope.allowed_paths.join(", ") : "(none — all non-denied paths allowed)"}`,
     `  denied_paths: ${policy.scope.denied_paths.join(", ")}`,
+    `  deny_delete: ${policy.effects.deny_delete.join(", ") || "(default .git only)"}`,
     `  budget_ok: ${budget.ok ? "yes" : "no"}`,
   ];
 

package/lib/gates.js

@@ -41,6 +41,8 @@ const GATE_SCRIPTS = {
 
 const AUX_SCRIPTS = {
   "loop-plan": "loop_plan.py",
+  "memory-index": "memory_index.py",
+  "memory-query": "memory_query.py",
 };
 
 const GUARDRAILS_SCRIPTS = { ...GATE_SCRIPTS, ...AUX_SCRIPTS };