@orchestrator-claude/definitions 3.44.0 → 3.44.1

package/hooks/workflow-guard.mjs

@@ -7321,9 +7321,69 @@ var require_dist = __commonJS({
 });
 
 // hooks/workflow-guard.ts
-import { dirname as dirname2, join as join4 } from "node:path";
+import { dirname as dirname2, join as join4, resolve as resolvePath, sep as PATH_SEP } from "node:path";
 import { existsSync as existsSync3 } from "node:fs";
 
+// ../vault-projection/dist/workflowArtifact/path.js
+var WORKFLOW_ARTIFACT_ROOT = "project-guidelines/workflows";
+var PATH_PATTERN = new RegExp(`^${WORKFLOW_ARTIFACT_ROOT}/([A-Za-z0-9][A-Za-z0-9-]*)/([a-z][a-z0-9_-]*)/([a-z0-9][a-z0-9_-]*)\\.md$`);
+function parseVaultPath(path) {
+  const match = PATH_PATTERN.exec(path);
+  if (match === null)
+    return null;
+  const [, workflowId, phase, artifactType] = match;
+  if (workflowId === void 0 || phase === void 0 || artifactType === void 0)
+    return null;
+  return { workflowId, phase, artifactType };
+}
+
+// ../vault-projection/dist/workflowArtifact/wire.js
+var VERIFY_VERDICT_CODES = [
+  "ARTIFACT_INTEGRITY_VIOLATED",
+  "ARTIFACT_NOT_REGISTERED",
+  "ARTIFACT_CONTENT_MISSING"
+];
+var WORKFLOW_ARTIFACT_ERROR_CODES = [
+  "WORKFLOW_NOT_FOUND",
+  "PHASE_NOT_CURRENT",
+  "INVALID_ARTIFACT_TYPE",
+  "INVALID_CONTENT_HASH",
+  "VALIDATION_ERROR",
+  "PATH_MISMATCH",
+  "IMPLEMENTS_WITHOUT_RFC",
+  "IMPLEMENTS_MISMATCH",
+  "INVALID_FRONTMATTER",
+  "INTERNAL_ERROR"
+];
+var PROBLEM_TYPE_BASE = "https://api.orchestrator.io/errors/";
+function problemCode(body) {
+  if (typeof body !== "object" || body === null)
+    return null;
+  const { code, type } = body;
+  if (typeof code === "string" && code.length > 0)
+    return code;
+  if (typeof type === "string" && type.startsWith(PROBLEM_TYPE_BASE)) {
+    const tail = type.slice(PROBLEM_TYPE_BASE.length);
+    return tail.length > 0 && !tail.includes("/") ? tail : null;
+  }
+  return null;
+}
+
+// ../vault-projection/dist/workflowArtifact/document.js
+var import_yaml2 = __toESM(require_dist(), 1);
+
+// ../vault-projection/dist/vaultWalker.js
+var import_yaml = __toESM(require_dist(), 1);
+
+// ../vault-projection/dist/workflowArtifact/document.js
+var utf8 = new TextDecoder("utf-8", { ignoreBOM: true });
+
+// ../vault-projection/dist/gate/constitution.js
+var import_yaml4 = __toESM(require_dist(), 1);
+
+// ../vault-projection/dist/relationshipsVocab.js
+var import_yaml3 = __toESM(require_dist(), 1);
+
 // hooks/lib/api-client.ts
 import { readFileSync, writeFileSync, mkdirSync, statSync, unlinkSync, readdirSync } from "node:fs";
 import { join as join2 } from "node:path";
@@ -7385,8 +7445,15 @@ if ((STATE_DIR_OVERRIDE === void 0 || STATE_DIR_OVERRIDE === "") && PROJECT_ROOT
   );
 }
 var API_URL = process.env.ORCHESTRATOR_API_URL || "http://localhost:3001";
-var AUTH_EMAIL = process.env.ORCHESTRATOR_ADMIN_EMAIL || process.env.ORCHESTRATOR_AUTH_EMAIL || "system@orchestrator.local";
-var AUTH_PASSWORD = process.env.ORCHESTRATOR_ADMIN_PASSWORD || process.env.ORCHESTRATOR_AUTH_PASSWORD || "system123";
+var DEFAULT_AUTH_EMAIL = "system@orchestrator.local";
+var MISSING_CREDENTIAL_MESSAGE = "no credential configured (ORCHESTRATOR_ADMIN_PASSWORD / ORCHESTRATOR_AUTH_PASSWORD unset or empty) - login not attempted";
+var missingCredentialLogged = false;
+function resolveAuthCredentials() {
+  const password = (process.env.ORCHESTRATOR_ADMIN_PASSWORD ?? "").trim() || (process.env.ORCHESTRATOR_AUTH_PASSWORD ?? "").trim();
+  if (!password) return null;
+  const email = process.env.ORCHESTRATOR_ADMIN_EMAIL || process.env.ORCHESTRATOR_AUTH_EMAIL || DEFAULT_AUTH_EMAIL;
+  return { email, password };
+}
 var PROJECT_ID = process.env.ORCHESTRATOR_PROJECT_ID || "";
 function resolveHookProjectRoot(cwd) {
   return resolveProjectRoot(cwd);
@@ -7427,6 +7494,9 @@ async function ensureProjectIdResolved(token) {
     );
   }
 }
+function getEffectiveProjectId() {
+  return PROJECT_ID;
+}
 function normalizeAgentName(subagentType) {
   const i = subagentType.lastIndexOf(":");
   return i === -1 ? subagentType : subagentType.slice(i + 1);
@@ -7452,6 +7522,14 @@ function getCachedToken() {
   return null;
 }
 async function login() {
+  const credentials = resolveAuthCredentials();
+  if (credentials === null) {
+    if (!missingCredentialLogged) {
+      missingCredentialLogged = true;
+      log("API-CLIENT", MISSING_CREDENTIAL_MESSAGE);
+    }
+    return null;
+  }
   try {
     const resp = await fetch(`${API_URL}/api/v1/auth/login`, {
       method: "POST",
@@ -7459,7 +7537,7 @@ async function login() {
         "Content-Type": "application/json",
         "X-Project-ID": PROJECT_ID
       },
-      body: JSON.stringify({ email: AUTH_EMAIL, password: AUTH_PASSWORD }),
+      body: JSON.stringify({ email: credentials.email, password: credentials.password }),
       signal: AbortSignal.timeout(5e3)
     });
     if (!resp.ok) return null;
@@ -7567,7 +7645,7 @@ function outputPreToolUse(opts) {
 }
 
 // hooks/lib/observations-helper.ts
-var import_yaml = __toESM(require_dist(), 1);
+var import_yaml5 = __toESM(require_dist(), 1);
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "node:fs";
 import { join as join3 } from "node:path";
 var MAX_ENTRIES = 50;
@@ -7589,7 +7667,7 @@ function appendObservation(memoryDir, agent, entry) {
     if (existsSync2(filePath)) {
       try {
         const raw = readFileSync2(filePath, "utf-8");
-        const parsed = (0, import_yaml.parse)(raw);
+        const parsed = (0, import_yaml5.parse)(raw);
         if (parsed?.entries && Array.isArray(parsed.entries)) {
           data = {
             schema: "observations/v1",
@@ -7608,7 +7686,7 @@ function appendObservation(memoryDir, agent, entry) {
     if (data.entries.length > MAX_ENTRIES) {
       data.entries = data.entries.slice(data.entries.length - MAX_ENTRIES);
     }
-    writeFileSync2(filePath, (0, import_yaml.stringify)(data), "utf-8");
+    writeFileSync2(filePath, (0, import_yaml5.stringify)(data), "utf-8");
   } catch (err) {
     console.warn(
       `[OBSERVATIONS] Failed to write observation for agent '${agent}': ${err instanceof Error ? err.message : String(err)}`
@@ -7616,8 +7694,356 @@ function appendObservation(memoryDir, agent, entry) {
   }
 }
 
+// hooks/lib/artifact-producers.ts
+var NAMES = [
+  "adversarial-reviewer",
+  "agentic-architect",
+  "api-extractor",
+  "architecture-mediator",
+  "azure-devops-engineer",
+  "backend-architect",
+  "business-rule-miner",
+  "cicd-platform-engineer",
+  "ciclo-engineer",
+  "code-archaeologist",
+  "contract-architect",
+  "datamodel-architect",
+  "frontend-architect",
+  "frontend-engineer",
+  "harness-architect",
+  "harness-engineer",
+  "implementer",
+  "infra-architect",
+  "legacy-discoverer",
+  "legacy-synthesizer",
+  "methodology-researcher",
+  "operational-artifact-builder",
+  "planner",
+  "presentation-engineer",
+  "python-data-engineer",
+  "researcher",
+  "reviewer",
+  "schema-extractor",
+  "specifier",
+  "task-generator"
+];
+function refuser(constant) {
+  return () => {
+    throw new TypeError(`${constant} is frozen: edit the list in artifact-producers.ts`);
+  };
+}
+function frozenSet(values, constant) {
+  const set = new Set(values);
+  const refuse = refuser(constant);
+  Object.defineProperties(set, {
+    add: { value: refuse },
+    delete: { value: refuse },
+    clear: { value: refuse }
+  });
+  return Object.freeze(set);
+}
+var ARTIFACT_PRODUCER_AGENTS = frozenSet(
+  NAMES,
+  "ARTIFACT_PRODUCER_AGENTS"
+);
+var PINNED_ADVERSARIAL_REVIEW_TYPE = "adversarial_review";
+function frozenMap(entries) {
+  const map = new Map(entries);
+  const refuse = refuser("VAULT_ONLY_WRITERS");
+  Object.defineProperties(map, {
+    set: { value: refuse },
+    delete: { value: refuse },
+    clear: { value: refuse }
+  });
+  return Object.freeze(map);
+}
+var VAULT_ONLY_WRITERS = frozenMap([
+  ["adversarial-reviewer", frozenSet([PINNED_ADVERSARIAL_REVIEW_TYPE], "VAULT_ONLY_WRITERS")],
+  ["methodology-researcher", null]
+]);
+
+// hooks/lib/workflow-artifact-client.ts
+function defaultClientDeps() {
+  const envUrl = process.env.ORCHESTRATOR_API_URL;
+  return {
+    fetch: (input, init) => fetch(input, init),
+    getToken,
+    getProjectId: getEffectiveProjectId,
+    // An EMPTY value falls back too, exactly like api-client.ts (`||` there).
+    apiUrl: envUrl !== void 0 && envUrl !== "" ? envUrl : "http://localhost:3001",
+    timeoutMs: 5e3
+  };
+}
+var AUTH_CODES = /* @__PURE__ */ new Set(["unauthorized", "forbidden"]);
+var REJECT_CODES = /* @__PURE__ */ new Set([
+  ...WORKFLOW_ARTIFACT_ERROR_CODES.filter((c) => c !== "INTERNAL_ERROR"),
+  "FST_ERR_VALIDATION"
+]);
+var VERDICTS = new Set(VERIFY_VERDICT_CODES);
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function causeOfThrow(e) {
+  const name = e?.name;
+  return name === "TimeoutError" || name === "AbortError" ? "timeout" : "network";
+}
+async function readJson(resp) {
+  try {
+    return { parsed: true, body: await resp.json() };
+  } catch {
+    return { parsed: false };
+  }
+}
+async function send(deps, path, body) {
+  const token = await deps.getToken();
+  if (token === null || token === "") {
+    return { ok: false, failure: { kind: "unavailable", cause: "no-token" } };
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "X-Project-ID": deps.getProjectId()
+  };
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  try {
+    const resp = await deps.fetch(`${deps.apiUrl}${path}`, {
+      method: body === void 0 ? "GET" : "POST",
+      headers,
+      ...body !== void 0 && { body: JSON.stringify(body) },
+      signal: AbortSignal.timeout(deps.timeoutMs)
+    });
+    return { ok: true, resp };
+  } catch (e) {
+    return { ok: false, failure: { kind: "unavailable", cause: causeOfThrow(e) } };
+  }
+}
+async function classifyFailure(resp, known) {
+  const read = await readJson(resp);
+  const code = read.parsed ? problemCode(read.body) : null;
+  const detail = read.parsed && isObject(read.body) && typeof read.body.detail === "string" ? read.body.detail : void 0;
+  const base = {
+    httpStatus: resp.status,
+    ...code !== null && { code },
+    ...detail !== void 0 && { detail }
+  };
+  if (resp.status >= 500) return { kind: "unavailable", cause: "http-5xx", ...base };
+  if (code !== null && AUTH_CODES.has(code)) {
+    return { kind: "unavailable", cause: "unauthorized", ...base };
+  }
+  if (code !== null && known.has(code)) {
+    return {
+      kind: "rejected",
+      httpStatus: resp.status,
+      code,
+      ...detail !== void 0 && { detail }
+    };
+  }
+  return { kind: "unavailable", cause: "unknown-response", ...base };
+}
+var badBody = (httpStatus) => ({
+  kind: "unavailable",
+  cause: "bad-body",
+  httpStatus
+});
+async function guard(run) {
+  try {
+    return await run();
+  } catch (e) {
+    return {
+      kind: "unavailable",
+      cause: "exception",
+      detail: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function probeWorkflow(workflowId, deps = defaultClientDeps()) {
+  return guard(async () => {
+    const sent = await send(deps, `/api/v1/workflows/${encodeURIComponent(workflowId)}/status`);
+    if (!sent.ok) return sent.failure;
+    const { resp } = sent;
+    if (!resp.ok) {
+      const failure = await classifyFailure(resp, /* @__PURE__ */ new Set(["not-found"]));
+      return failure.kind === "rejected" ? { kind: "not-found" } : failure;
+    }
+    const read = await readJson(resp);
+    if (!read.parsed || !isObject(read.body)) return badBody(resp.status);
+    const { workflowId: id, status, currentPhase } = read.body;
+    const phaseOk = currentPhase === null || typeof currentPhase === "string";
+    if (id !== workflowId || typeof status !== "string" || !phaseOk) return badBody(resp.status);
+    return { kind: "ok", workflowId: id, status, currentPhase };
+  });
+}
+
 // hooks/workflow-guard.ts
 var HOOK = "WORKFLOW-GUARD";
+var WORKFLOWS_SEGMENT = `/${WORKFLOW_ARTIFACT_ROOT}/`;
+var ACTIVE_WORKFLOW_STATUSES = /* @__PURE__ */ new Set([
+  "in_progress",
+  "awaiting_agent",
+  "awaiting_approval"
+]);
+var R7_RUNBOOK = [
+  'Runbook "API fora" (RFC-044 F3):',
+  '  1. curl -sS -m 3 "${ORCHESTRATOR_API_URL:-http://localhost:3001}/api/v1/health"  (200 = API up)',
+  "  2. 200 but still denied (R7-NO-TOKEN, or cause no-token): check ORCHESTRATOR_ADMIN_EMAIL, ORCHESTRATOR_ADMIN_PASSWORD, ORCHESTRATOR_PROJECT_ID",
+  "  3. no answer: bring the API back up (the project container/service); the hook retries on the next Write",
+  "SKIP_WORKFLOW_GUARD nao se aplica a R7, nem .orchestrator/.unmanaged; nao edite hooks.json nem os .mjs."
+].join("\n");
+function matchR7Path(filePath) {
+  if (filePath.length === 0) return { kind: "none" };
+  const resolved = resolvePath(filePath);
+  const at = resolved.indexOf(WORKFLOWS_SEGMENT);
+  if (at === -1) return { kind: "none" };
+  const rel = resolved.slice(at + 1);
+  if (filePath.endsWith("/")) return { kind: "shape", rel };
+  const key = parseVaultPath(rel);
+  return key === null ? { kind: "shape", rel } : { kind: "key", rel, ...key };
+}
+function r7Deny(label, message, logLine, extra = {}) {
+  return {
+    matchedRule: "R7",
+    emitOutput: true,
+    output: {
+      decision: "deny",
+      reason: `Workflow Guard ${label}: ${message}`,
+      context: "R7 (RFC-044 F3): project-guidelines/workflows/<wf>/<phase>/<type>.md is written only by an artifact-producing sub-agent, while <wf> is active and in <phase>."
+    },
+    logMessages: [`DENY (${label}) ${logLine}`],
+    ...extra
+  };
+}
+function r7FromProbe(probe, target, agent) {
+  const where = `file=${target.rel} agent=${agent}`;
+  if (probe.kind === "not-found") {
+    return r7Deny(
+      "R7-WORKFLOW-NOT-FOUND",
+      `workflow ${target.workflowId} (from the path) does not exist in this project.`,
+      where
+    );
+  }
+  if (probe.kind === "unavailable") {
+    const label = probe.cause === "unauthorized" ? "R7-NO-TOKEN" : "R7-API-UNAVAILABLE";
+    return r7Deny(
+      label,
+      `could not confirm workflow ${target.workflowId} with the API (cause: ${probe.cause}${probe.httpStatus === void 0 ? "" : `, HTTP ${String(probe.httpStatus)}`}).
+${R7_RUNBOOK}`,
+      `${where} cause=${probe.cause}`
+    );
+  }
+  if (!ACTIVE_WORKFLOW_STATUSES.has(probe.status)) {
+    return r7Deny(
+      "R7-WORKFLOW-NOT-ACTIVE",
+      `workflow ${target.workflowId} is ${probe.status}, not active.`,
+      where
+    );
+  }
+  if ((probe.currentPhase ?? "").toLowerCase() !== target.phase) {
+    return r7Deny(
+      "R7-PHASE-NOT-CURRENT",
+      `workflow ${target.workflowId} is in phase ${String(probe.currentPhase)}, not ${target.phase}.`,
+      where
+    );
+  }
+  return {
+    matchedRule: "R7",
+    emitOutput: true,
+    output: {
+      decision: "allow",
+      context: `R7: ${agent} writes ${target.rel} (workflow ${target.workflowId} active, phase ${target.phase}).`
+    },
+    logMessages: [`ALLOW (R7) ${where}`]
+  };
+}
+function decideR7(input) {
+  const match = matchR7Path(input.filePath);
+  if (match.kind === "none") return null;
+  if (input.targetProjectRoot === null || input.isUnmanaged) return null;
+  return decideR7ForMatch(input, match);
+}
+function decideR7ForMatch(input, match) {
+  const agent = input.agentType ? normalizeAgentName(input.agentType) : "";
+  if (agent === "") {
+    return r7Deny(
+      "R7-MAIN-AGENT",
+      `${match.rel} is written only by an artifact-producing sub-agent, never by the main agent (Q-PM-5).`,
+      `file=${match.rel}`
+    );
+  }
+  if (!ARTIFACT_PRODUCER_AGENTS.has(agent)) {
+    return r7Deny(
+      "R7-NOT-PRODUCER",
+      `agent ${agent} is not an artifact producer (ARTIFACT_PRODUCER_AGENTS).`,
+      `file=${match.rel} agent=${agent}`
+    );
+  }
+  if (match.kind === "shape") {
+    return r7Deny(
+      "R7-SHAPE",
+      `${match.rel} is not project-guidelines/workflows/<workflow_id>/<phase>/<artifact_type>.md.`,
+      `file=${match.rel} agent=${agent}`
+    );
+  }
+  const target = { rel: match.rel, workflowId: match.workflowId, phase: match.phase };
+  if (input.r7Probe === void 0) {
+    return r7Deny("R7-PROBE-PENDING", "workflow not confirmed yet.", `file=${match.rel}`, {
+      r7NeedsProbe: { workflowId: match.workflowId, phase: match.phase }
+    });
+  }
+  return r7FromProbe(input.r7Probe, target, agent);
+}
+function vaultOnlyWriter(agentType) {
+  if (agentType === "") return null;
+  const agent = normalizeAgentName(agentType);
+  return VAULT_ONLY_WRITERS.has(agent) ? agent : null;
+}
+var R8_CONTEXT = "R8 (RFC-044 F3, S6c): this agent writes only (1) its artifact project-guidelines/workflows/<wf>/<phase>/<type>.md of a managed project, under R7, and (2) its own memory under .claude/agent-memory/<slug>/. SKIP_WORKFLOW_GUARD does not apply.";
+function r8Deny(label, message, logLine) {
+  return {
+    matchedRule: "R8",
+    emitOutput: true,
+    output: {
+      decision: "deny",
+      reason: `Workflow Guard ${label}: ${message}`,
+      context: R8_CONTEXT
+    },
+    logMessages: [`DENY (${label}) ${logLine}`]
+  };
+}
+function isOwnMemory(filePath, root, agent) {
+  const dir = join4(root, ".claude", "agent-memory", agent) + PATH_SEP;
+  return resolvePath(filePath).startsWith(dir);
+}
+function decideR8(input) {
+  const agent = vaultOnlyWriter(input.agentType);
+  if (agent === null) return null;
+  const where = `file=${input.filePath} agent=${agent}`;
+  const match = matchR7Path(input.filePath);
+  if (match.kind !== "none" && input.targetProjectRoot !== null && !input.isUnmanaged) {
+    const types = VAULT_ONLY_WRITERS.get(agent) ?? null;
+    if (match.kind === "key" && types !== null && !types.has(match.artifactType)) {
+      return r8Deny(
+        "R8-TYPE",
+        `agent ${agent} writes only ${[...types].join(", ")} under workflows/, not ${match.artifactType} (R-6: never the artifact under review).`,
+        `file=${match.rel} agent=${agent}`
+      );
+    }
+    return decideR7ForMatch(input, match);
+  }
+  if (input.targetProjectRoot !== null && isOwnMemory(input.filePath, input.targetProjectRoot, agent)) {
+    return { matchedRule: "R8", emitOutput: false, logMessages: [`ALLOW (R8-MEMORY) ${where}`] };
+  }
+  return r8Deny(
+    "R8-OUTSIDE-VAULT",
+    `agent ${agent} may not write ${input.filePath}. It writes only project-guidelines/workflows/<wf>/<phase>/<type>.md of a managed project (R7) and its own memory .claude/agent-memory/${agent}/.`,
+    where
+  );
+}
+function r8ExceptionDecision(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return r8Deny("R8-EXCEPTION", `unexpected error (${message}).`, "exception");
+}
+function r7ExceptionDecision(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return r7Deny("R7-EXCEPTION", `unexpected error (${message}).
+${R7_RUNBOOK}`, "exception");
+}
 var CONFIG_DOC_RE = /\.(json|ya?ml|md|env(\..*)?)$/;
 function decideWorkflowGuardAction(input) {
   const {
@@ -7630,6 +8056,10 @@ function decideWorkflowGuardAction(input) {
     agentId,
     agentType
   } = input;
+  const r8 = decideR8(input);
+  if (r8 !== null) return r8;
+  const r7 = decideR7(input);
+  if (r7 !== null) return r7;
   if (skipWorkflowGuard) {
     return {
       matchedRule: 1,
@@ -7784,17 +8214,25 @@ function decideWorkflowGuardAction(input) {
     logMessages: ["DENY (no active workflow)"]
   };
 }
-async function main() {
-  const stdin = await readStdin();
+async function decideWithProbe(input, needs, deps) {
+  try {
+    const r7Probe = await deps.probeWorkflow(needs.workflowId);
+    return decideWorkflowGuardAction({ ...input, r7Probe });
+  } catch (e) {
+    return r7ExceptionDecision(e);
+  }
+}
+async function mainWithDeps(deps) {
+  const stdin = await deps.readStdin();
   const filePath = getField(stdin, "tool_input.file_path") || getField(stdin, "file_path") || getField(stdin, "input.file_path");
-  log(HOOK, `file_path=${filePath}`);
-  const skipWorkflowGuard = process.env.SKIP_WORKFLOW_GUARD === "true";
-  const skipSubagentGuard = process.env.SKIP_SUBAGENT_GUARD === "true";
+  deps.log(`file_path=${filePath}`);
+  const skipWorkflowGuard = deps.env.SKIP_WORKFLOW_GUARD === "true";
+  const skipSubagentGuard = deps.env.SKIP_SUBAGENT_GUARD === "true";
   const agentId = getField(stdin, "agent_id");
   const agentType = getField(stdin, "agent_type");
   const targetDir = filePath.length > 0 ? dirname2(filePath) : process.cwd();
-  const targetProjectRoot = resolveHookProjectRoot(targetDir);
-  const isUnmanaged = targetProjectRoot !== null && existsSync3(join4(targetProjectRoot, ".orchestrator", ".unmanaged"));
+  const targetProjectRoot = deps.resolveHookProjectRoot(targetDir);
+  const isUnmanaged = targetProjectRoot !== null && deps.isUnmanaged(targetProjectRoot);
   const baseInput = {
     filePath,
     skipWorkflowGuard,
@@ -7802,38 +8240,75 @@ async function main() {
     targetProjectRoot,
     isUnmanaged,
     agentId,
-    agentType
+    agentType,
+    workflow: null
   };
-  let decision = decideWorkflowGuardAction({ ...baseInput, workflow: null });
-  if (decision.matchedRule === 7) {
-    const activeWorkflow = await getActiveWorkflow();
+  let decision;
+  try {
+    decision = decideWorkflowGuardAction(baseInput);
+  } catch (e) {
+    if (vaultOnlyWriter(agentType) !== null) {
+      decision = r8ExceptionDecision(e);
+    } else {
+      if (matchR7Path(filePath).kind === "none") throw e;
+      decision = r7ExceptionDecision(e);
+    }
+  }
+  if (decision.r7NeedsProbe) {
+    decision = await decideWithProbe(baseInput, decision.r7NeedsProbe, deps);
+  } else if (decision.matchedRule === 7) {
+    const activeWorkflow = await deps.getActiveWorkflow();
     let workflow = null;
     if (activeWorkflow) {
-      const mode = await getWorkflowMode(activeWorkflow.id);
+      const mode = await deps.getWorkflowMode(activeWorkflow.id);
       workflow = { id: activeWorkflow.id, mode, currentPhase: activeWorkflow.currentPhase };
     }
     decision = decideWorkflowGuardAction({ ...baseInput, workflow });
   }
   for (const line of decision.logMessages) {
-    log(HOOK, line);
+    deps.log(line);
   }
   if (decision.observation) {
     try {
-      const sessionId = getField(stdin, "session_id") || getField(stdin, "claude_session_id") || "";
-      const memoryBaseDir = resolveAgentMemoryBaseDir(process.cwd());
-      appendObservation(memoryBaseDir, "main", {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        session_id: sessionId,
-        ...decision.observation
-      });
+      deps.appendObservation(stdin, decision.observation);
     } catch {
     }
   }
   if (decision.emitOutput && decision.output) {
-    outputPreToolUse(decision.output);
+    deps.output(decision.output);
   }
 }
+var defaultDeps = {
+  readStdin,
+  env: process.env,
+  resolveHookProjectRoot,
+  isUnmanaged: (projectRoot) => existsSync3(join4(projectRoot, ".orchestrator", ".unmanaged")),
+  getActiveWorkflow,
+  getWorkflowMode,
+  probeWorkflow: (workflowId) => probeWorkflow(workflowId),
+  output: outputPreToolUse,
+  log: (line) => {
+    log(HOOK, line);
+  },
+  appendObservation: (stdin, observation) => {
+    const sessionId = getField(stdin, "session_id") || getField(stdin, "claude_session_id") || "";
+    const memoryBaseDir = resolveAgentMemoryBaseDir(process.cwd());
+    appendObservation(memoryBaseDir, "main", {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      session_id: sessionId,
+      ...observation
+    });
+  }
+};
+async function main() {
+  await mainWithDeps(defaultDeps);
+}
 main().catch(() => process.exit(0));
 export {
-  decideWorkflowGuardAction
+  R7_RUNBOOK,
+  decideWorkflowGuardAction,
+  mainWithDeps,
+  matchR7Path,
+  r7ExceptionDecision,
+  r8ExceptionDecision
 };