@deftai/directive-core 0.81.0 → 0.83.0

package/dist/init-deposit/agent-hooks.js

@@ -1,7 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { assertDepositContained } from "../deposit/contain.js";
+import { assertCursorApplyPatchMatchersDisjoint, CURSOR_APPLY_PATCH_ADAPTER_RELATIVE, CURSOR_APPLY_PATCH_ADAPTER_SOURCE, CURSOR_GENERIC_WRITE_HOOK_MATCHER, cursorApplyPatchAdapterEntry, DEFT_CURSOR_ADAPTER_COMMAND_MARKER, } from "../hooks/cursor-hooks.js";
 import { DIRECT_WRITE_HOOK_MATCHER, SPAWN_HOOK_MATCHER } from "../hooks/tools.js";
+import { isHostHookDepositEnabled, loadHostHooksPolicyFromProject, } from "../policy/host-hooks.js";
+export { CURSOR_GENERIC_WRITE_HOOK_MATCHER, DEFT_CURSOR_ADAPTER_COMMAND_MARKER, } from "../hooks/cursor-hooks.js";
 export { DIRECT_WRITE_HOOK_MATCHER, SPAWN_HOOK_MATCHER } from "../hooks/tools.js";
 export const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
 export const AGENT_HOOK_PATHS = [
@@ -63,9 +66,18 @@ function nestedCommands(value) {
 function isManagedNestedGroup(value) {
     return nestedCommands(value).some((value) => value.includes(DEFT_HOOK_COMMAND_MARKER));
 }
+function isManagedNestedGroupForHost(value, host) {
+    return nestedCommands(value).some((command) => command.includes(DEFT_HOOK_COMMAND_MARKER) && command.includes(`--host ${host}`));
+}
 function isManagedCursorEntry(value) {
     const entry = object(value);
-    return typeof entry?.command === "string" && entry.command.includes(DEFT_HOOK_COMMAND_MARKER);
+    if (typeof entry?.command !== "string")
+        return false;
+    return (entry.command.includes(DEFT_HOOK_COMMAND_MARKER) ||
+        entry.command.includes(DEFT_CURSOR_ADAPTER_COMMAND_MARKER));
+}
+function isManagedCursorEntryForHost(value) {
+    return isManagedCursorEntry(value);
 }
 function nestedGroup(host, event, matcher) {
     return {
@@ -97,7 +109,40 @@ function mergeNestedConfig(config, path, host, options = {}) {
     }
     return { ...config, hooks };
 }
+function stripManagedNestedConfig(config, path, host) {
+    const hooks = hooksObject(config, path);
+    const nextHooks = {};
+    for (const key of ["SessionStart", "PreToolUse", "PreCompact", "PostCompact"]) {
+        if (!(key in hooks))
+            continue;
+        const filtered = eventArray(hooks, key, path).filter((entry) => !isManagedNestedGroupForHost(entry, host));
+        if (filtered.length > 0)
+            nextHooks[key] = filtered;
+    }
+    if (Object.keys(nextHooks).length === 0) {
+        const { hooks: _hooks, ...rest } = config;
+        return rest;
+    }
+    return { ...config, hooks: nextHooks };
+}
+function stripManagedCursorConfig(config, path) {
+    const hooks = hooksObject(config, path);
+    const nextHooks = {};
+    for (const key of ["sessionStart", "preToolUse", "preCompact"]) {
+        if (!(key in hooks))
+            continue;
+        const filtered = eventArray(hooks, key, path).filter((entry) => !isManagedCursorEntryForHost(entry));
+        if (filtered.length > 0)
+            nextHooks[key] = filtered;
+    }
+    if (Object.keys(nextHooks).length === 0) {
+        const { hooks: _hooks, version: _version, ...rest } = config;
+        return rest;
+    }
+    return { ...config, version: 1, hooks: nextHooks };
+}
 function mergeCursorConfig(config, path) {
+    assertCursorApplyPatchMatchersDisjoint();
     const hooks = hooksObject(config, path);
     const session = eventArray(hooks, "sessionStart", path).filter((entry) => !isManagedCursorEntry(entry));
     const preTool = eventArray(hooks, "preToolUse", path).filter((entry) => !isManagedCursorEntry(entry));
@@ -105,9 +150,10 @@ function mergeCursorConfig(config, path) {
     hooks.sessionStart = [...session, { command: command("cursor", "session.start"), timeout: 5 }];
     hooks.preToolUse = [
         ...preTool,
+        cursorApplyPatchAdapterEntry(),
         {
             command: command("cursor", "tool.before"),
-            matcher: DIRECT_WRITE_HOOK_MATCHER,
+            matcher: CURSOR_GENERIC_WRITE_HOOK_MATCHER,
             failClosed: true,
             timeout: 5,
         },
@@ -121,6 +167,15 @@ function mergeCursorConfig(config, path) {
     hooks.preCompact = [...preCompact, { command: command("cursor", "session.compact"), timeout: 5 }];
     return { ...config, version: 1, hooks };
 }
+function writeTextIfChanged(path, contents) {
+    if (existsSync(path) && readFileSync(path, "utf8") === contents)
+        return false;
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.deft-${process.pid}.tmp`;
+    writeFileSync(temporary, contents, "utf8");
+    renameSync(temporary, path);
+    return true;
+}
 function writeJsonIfChanged(path, payload) {
     const next = `${JSON.stringify(payload, null, 2)}\n`;
     if (existsSync(path) && readFileSync(path, "utf8") === next)
@@ -132,41 +187,93 @@ function writeJsonIfChanged(path, payload) {
     return true;
 }
 /** Merge Directive-owned project hook entries without replacing user configuration. */
-export function writeAgentHookDeposit(projectRoot, io = { printf: () => undefined }) {
+export function writeAgentHookDeposit(projectRoot, io = { printf: () => undefined }, hostHooksPolicy = loadHostHooksPolicyFromProject(projectRoot)) {
     const changedPaths = [];
+    const strippedPaths = [];
     const definitions = [
         {
+            host: "claude",
             path: AGENT_HOOK_PATHS[0],
             merge: (config, path) => mergeNestedConfig(config, path, "claude", { compact: true }),
+            strip: (config, path) => stripManagedNestedConfig(config, path, "claude"),
         },
         {
+            host: "grok",
             path: AGENT_HOOK_PATHS[1],
             merge: (config, path) => mergeNestedConfig(config, path, "grok", { compact: true }),
+            strip: (config, path) => stripManagedNestedConfig(config, path, "grok"),
+        },
+        {
+            host: "cursor",
+            path: AGENT_HOOK_PATHS[2],
+            merge: mergeCursorConfig,
+            strip: stripManagedCursorConfig,
         },
-        { path: AGENT_HOOK_PATHS[2], merge: mergeCursorConfig },
         {
+            host: "codex",
             path: AGENT_HOOK_PATHS[3],
             merge: (config, path) => mergeNestedConfig(config, path, "codex", { compact: false }),
+            strip: (config, path) => stripManagedNestedConfig(config, path, "codex"),
         },
     ];
     const prepared = definitions.map((definition) => {
         const absolute = join(projectRoot, definition.path);
         assertDepositContained(projectRoot, absolute);
-        const merged = definition.merge(readConfig(absolute), absolute);
-        return { ...definition, absolute, merged };
+        if (!isHostHookDepositEnabled(definition.host, hostHooksPolicy)) {
+            if (!existsSync(absolute))
+                return { mode: "skip" };
+            return {
+                mode: "strip",
+                absolute,
+                path: definition.path,
+                payload: definition.strip(readConfig(absolute), absolute),
+            };
+        }
+        return {
+            mode: "merge",
+            absolute,
+            path: definition.path,
+            payload: definition.merge(readConfig(absolute), absolute),
+        };
     });
-    for (const definition of prepared) {
-        if (writeJsonIfChanged(definition.absolute, definition.merged)) {
-            changedPaths.push(definition.path);
+    for (const item of prepared) {
+        if (item.mode === "skip")
+            continue;
+        if (writeJsonIfChanged(item.absolute, item.payload)) {
+            if (item.mode === "strip")
+                strippedPaths.push(item.path);
+            else
+                changedPaths.push(item.path);
+        }
+    }
+    const adapterAbsolute = join(projectRoot, CURSOR_APPLY_PATCH_ADAPTER_RELATIVE);
+    assertDepositContained(projectRoot, adapterAbsolute);
+    if (isHostHookDepositEnabled("cursor", hostHooksPolicy)) {
+        if (writeTextIfChanged(adapterAbsolute, CURSOR_APPLY_PATCH_ADAPTER_SOURCE)) {
+            if (!changedPaths.includes(AGENT_HOOK_PATHS[2])) {
+                changedPaths.push(AGENT_HOOK_PATHS[2]);
+            }
+        }
+    }
+    else if (existsSync(adapterAbsolute)) {
+        rmSync(adapterAbsolute, { force: true });
+        if (!strippedPaths.includes(AGENT_HOOK_PATHS[2])) {
+            strippedPaths.push(AGENT_HOOK_PATHS[2]);
         }
     }
     if (changedPaths.length > 0) {
         io.printf(`Installed Directive agent hooks: ${changedPaths.join(", ")}\n`);
     }
-    else {
+    if (strippedPaths.length > 0) {
+        io.printf(`Removed Directive-managed agent hooks (plan.policy.hostHooks opt-out): ${strippedPaths.join(", ")}\n`);
+    }
+    if (changedPaths.length === 0 && strippedPaths.length === 0) {
         io.printf("Directive agent hooks already current.\n");
     }
-    return { changed: changedPaths.length > 0, changedPaths };
+    return {
+        changed: changedPaths.length + strippedPaths.length > 0,
+        changedPaths: [...changedPaths, ...strippedPaths],
+    };
 }
 function hasNestedRegistration(config, host, options = {}) {
     const hooks = object(config.hooks);
@@ -202,11 +309,18 @@ function hasCursorRegistration(config) {
     const session = Array.isArray(hooks.sessionStart) ? hooks.sessionStart : [];
     const preTool = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
     const preCompact = Array.isArray(hooks.preCompact) ? hooks.preCompact : [];
+    const adapter = cursorApplyPatchAdapterEntry();
     return (session.some((entry) => object(entry)?.command === command("cursor", "session.start")) &&
         preTool.some((entry) => {
             const hook = object(entry);
             return (hook?.command === command("cursor", "tool.before") &&
-                hook.matcher === DIRECT_WRITE_HOOK_MATCHER &&
+                hook.matcher === CURSOR_GENERIC_WRITE_HOOK_MATCHER &&
+                hook.failClosed === true);
+        }) &&
+        preTool.some((entry) => {
+            const hook = object(entry);
+            return (hook?.command === adapter.command &&
+                hook.matcher === adapter.matcher &&
                 hook.failClosed === true);
         }) &&
         preTool.some((entry) => {
@@ -218,7 +332,7 @@ function hasCursorRegistration(config) {
         preCompact.some((entry) => object(entry)?.command === command("cursor", "session.compact")));
 }
 /** Read-only registration probe shared by verify and doctor. */
-export function inspectAgentHookDeposit(projectRoot) {
+export function inspectAgentHookDeposit(projectRoot, hostHooksPolicy = loadHostHooksPolicyFromProject(projectRoot)) {
     const definitions = [
         {
             host: "claude",
@@ -250,6 +364,15 @@ export function inspectAgentHookDeposit(projectRoot) {
         const compactNote = definition.compactSupport === "unsupported"
             ? " Compact re-arm is not deposited for Codex (no native compact hook surface)."
             : " PreCompact/PostCompact or preCompact compact re-arm is deposited.";
+        if (!isHostHookDepositEnabled(definition.host, hostHooksPolicy)) {
+            return {
+                host: definition.host,
+                path: definition.path,
+                status: "healthy",
+                compactSupport: definition.compactSupport,
+                detail: `plan.policy.hostHooks.${definition.host} is false — Directive hook deposit is skipped for this host.`,
+            };
+        }
         if (!existsSync(absolute)) {
             return {
                 host: definition.host,

package/dist/init-deposit/hygiene.js

@@ -24,6 +24,7 @@ export function installerManagedMatchers() {
         { exact: ".claude/settings.json" },
         { exact: ".grok/hooks/deft.json" },
         { exact: ".cursor/hooks.json" },
+        { exact: ".cursor/hooks/deft-cursor-hook-adapter.mjs" },
         { exact: ".codex/hooks.json" },
         { exact: ".gitattributes" },
         { exact: ".gitignore" },

package/dist/intake/github-body-cli.js

@@ -17,6 +17,8 @@ function parseArgs(argv) {
             out.pr = Number.parseInt(argv[++i], 10);
         else if (arg === "--body-file")
             out.bodyFile = argv[++i];
+        else if (arg === "--out-file")
+            out.outFile = argv[++i];
     }
     return out;
 }

package/dist/intake/github-body.d.ts

@@ -9,6 +9,8 @@ export type RunGhApiFn = (args: readonly string[], options?: {
 /** Resolve the live GitHub CLI used for writes and mutation read-back. */
 export declare function resolveLiveGh(): string;
 export declare function readBody(bodyFile: string, stdinText?: string | null): string;
+/** Fail closed when live read-back body is flattened or mojibaked vs intended payload (#2607). */
+export declare function verifyBodyPostcondition(intended: string, live: string): void;
 export declare function createIssue(repo: string, options: {
     title: string;
     body: string;
@@ -35,6 +37,14 @@ export declare function editPrBody(repo: string, pr: number, options: {
     binary?: string | null;
     runFn?: RunGhApiFn;
 }): Record<string, unknown>;
+export declare function fetchIssueBody(repo: string, issue: number, options?: {
+    binary?: string | null;
+    runFn?: RunGhApiFn;
+}): string;
+export declare function writeIssueBodyToFile(repo: string, issue: number, outFile: string, options?: {
+    binary?: string | null;
+    runFn?: RunGhApiFn;
+}): string;
 export interface GitHubBodyCliArgs {
     command: string;
     repo?: string;
@@ -43,6 +53,7 @@ export interface GitHubBodyCliArgs {
     comment?: number;
     pr?: number;
     bodyFile?: string;
+    outFile?: string;
 }
 export declare function githubBodyMain(args: GitHubBodyCliArgs): number;
 //# sourceMappingURL=github-body.d.ts.map

package/dist/intake/github-body.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { defaultWhich } from "../scm/binary.js";
 import { call } from "../scm/call.js";
 export const DEFAULT_TIMEOUT_SECONDS = 60;
@@ -73,14 +73,62 @@ function requireIntField(obj, field) {
     }
     return value;
 }
+function requireStringField(obj, field) {
+    const value = obj[field];
+    if (typeof value !== "string") {
+        throw new GitHubBodyError(`response did not include string field ${JSON.stringify(field)}`);
+    }
+    return value;
+}
+function countNewlines(text) {
+    let count = 0;
+    for (const ch of text) {
+        if (ch === "\n")
+            count += 1;
+    }
+    return count;
+}
+function normalizeNewlines(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+/** Fail closed when live read-back body is flattened or mojibaked vs intended payload (#2607). */
+export function verifyBodyPostcondition(intended, live) {
+    if (intended === live) {
+        return;
+    }
+    if (normalizeNewlines(intended) === normalizeNewlines(live)) {
+        return;
+    }
+    const diagnoses = [];
+    if (live.includes("\uFFFD") && !intended.includes("\uFFFD")) {
+        diagnoses.push("live body contains U+FFFD replacement character not present in intended payload");
+    }
+    const intendedNl = countNewlines(intended);
+    const liveNl = countNewlines(live);
+    if (intendedNl > 0 && liveNl < intendedNl) {
+        diagnoses.push(`newline count mismatch (intended ${intendedNl}, live ${liveNl})`);
+    }
+    if (intended.includes("\n") && intended.replace(/\n/g, " ") === live) {
+        diagnoses.push("live body looks like intended newlines were collapsed to spaces (PowerShell string[] join)");
+    }
+    if (diagnoses.length > 0) {
+        throw new GitHubBodyError(`body postcondition failed: ${diagnoses.join("; ")}`);
+    }
+    throw new GitHubBodyError(`body postcondition failed: re-fetched body does not match intended payload (length intended=${intended.length}, live=${live.length})`);
+}
 function mutateWithReadback(mutationEndpoint, method, payload, readbackEndpoint, options = {}) {
+    const intendedBody = typeof payload.body === "string" ? payload.body : undefined;
     const mutation = runGhApiJson([mutationEndpoint, "--method", method, "--input", "-"], {
         inputText: jsonInput(payload),
         binary: options.binary,
         runFn: options.runFn,
     });
     const endpoint = typeof readbackEndpoint === "function" ? readbackEndpoint(mutation) : readbackEndpoint;
-    return runGhApiJson([endpoint], { binary: options.binary, runFn: options.runFn });
+    const readback = runGhApiJson([endpoint], { binary: options.binary, runFn: options.runFn });
+    if (intendedBody !== undefined) {
+        verifyBodyPostcondition(intendedBody, requireStringField(readback, "body"));
+    }
+    return readback;
 }
 export function createIssue(repo, options) {
     const [owner, name] = splitRepo(repo);
@@ -116,32 +164,55 @@ export function editPrBody(repo, pr, options) {
         runFn: options.runFn,
     });
 }
+export function fetchIssueBody(repo, issue, options = {}) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues/${issue}`;
+    const response = runGhApiJson([endpoint], { binary: options.binary, runFn: options.runFn });
+    return requireStringField(response, "body");
+}
+export function writeIssueBodyToFile(repo, issue, outFile, options = {}) {
+    const body = fetchIssueBody(repo, issue, options);
+    writeFileSync(outFile, body, { encoding: "utf8" });
+    return body;
+}
 export function githubBodyMain(args) {
     try {
-        const body = readBody(args.bodyFile ?? "-");
-        let result;
         switch (args.command) {
-            case "issue-create":
-                result = createIssue(args.repo, { title: args.title, body });
-                break;
-            case "issue-edit":
-                result = editIssueBody(args.repo, args.issue, { body });
-                break;
-            case "comment-create":
-                result = createIssueComment(args.repo, args.issue, { body });
-                break;
-            case "comment-edit":
-                result = editIssueCommentBody(args.repo, args.comment, { body });
-                break;
-            case "pr-edit":
-                result = editPrBody(args.repo, args.pr, { body });
-                break;
-            default:
-                process.stderr.write(`error: unknown command ${JSON.stringify(args.command)}\n`);
-                return 1;
+            case "issue-fetch": {
+                if (args.repo === undefined || args.issue === undefined || args.outFile === undefined) {
+                    process.stderr.write("error: issue-fetch requires --repo, --issue, and --out-file\n");
+                    return 1;
+                }
+                writeIssueBodyToFile(args.repo, args.issue, args.outFile);
+                return 0;
+            }
+            default: {
+                const body = readBody(args.bodyFile ?? "-");
+                let result;
+                switch (args.command) {
+                    case "issue-create":
+                        result = createIssue(args.repo, { title: args.title, body });
+                        break;
+                    case "issue-edit":
+                        result = editIssueBody(args.repo, args.issue, { body });
+                        break;
+                    case "comment-create":
+                        result = createIssueComment(args.repo, args.issue, { body });
+                        break;
+                    case "comment-edit":
+                        result = editIssueCommentBody(args.repo, args.comment, { body });
+                        break;
+                    case "pr-edit":
+                        result = editPrBody(args.repo, args.pr, { body });
+                        break;
+                    default:
+                        process.stderr.write(`error: unknown command ${JSON.stringify(args.command)}\n`);
+                        return 1;
+                }
+                process.stdout.write(`${JSON.stringify(result)}\n`);
+                return 0;
+            }
         }
-        process.stdout.write(`${JSON.stringify(result)}\n`);
-        return 0;
     }
     catch (exc) {
         process.stderr.write(`error: ${String(exc)}\n`);

package/dist/integration-e2e/helpers.js

@@ -98,7 +98,7 @@ export function createConsumerProject(parent) {
 export function writeScopeVbrief(projectRoot, folder, filename, status = "proposed") {
     const target = join(projectRoot, "xbrief", folder, filename);
     writeFileSync(target, `${JSON.stringify({
-        vBRIEFInfo: { version: "0.5" },
+        xBRIEFInfo: { version: "0.8" },
         plan: {
             title: "Consumer fixture scope",
             status,

package/dist/issue-sync/sync-from-xbrief.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 import { createIssueComment } from "../intake/github-body.js";
 import { provenanceIssueNumber, repoSlugFromUrl } from "../intake/issue-ingest.js";
 import { extractReferencesFromVbrief, GITHUB_ISSUE_REF_TYPES, parseIssueNumber, } from "../intake/reconcile-issues.js";
@@ -192,9 +193,11 @@ export function syncFromXbrief(options) {
     writeOut(`issue:sync-from-xbrief: posted comment to ${origin.repo}#${origin.number} (id: ${commentResult.id}).`);
     const writeFingerprint = options.writeFingerprint ??
         ((targetPath, stamped) => {
+            assertWriteTargetSafe(projectRoot, targetPath);
             writeFileSync(targetPath, `${JSON.stringify(stamped, null, 2)}\n`, "utf8");
         });
     try {
+        assertWriteTargetSafe(projectRoot, absPath);
         writeFingerprint(absPath, stampIssueSyncFingerprint(data, origin));
     }
     catch (exc) {

package/dist/lifecycle/events.d.ts

@@ -32,6 +32,7 @@ export interface BehavioralEventRecord {
 export declare function emit(name: string, payload: Record<string, unknown>, options?: {
     logPath?: string | null;
     detectedAt?: string | null;
+    projectRoot?: string | null;
 }): BehavioralEventRecord;
 /** Return all events from the log in emission order. */
 export declare function readEvents(logPath?: string | null): BehavioralEventRecord[];

package/dist/lifecycle/events.js

@@ -1,9 +1,10 @@
 import { randomBytes } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, writeSync, } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { contentRoot } from "../content-root.js";
 import { ATTRIBUTION_REQUIRED_PAYLOAD } from "../events/attribution-constants.js";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 /** Default event log location (project-local). */
 export const DEFAULT_EVENT_LOG = join(".deft-cache", "events.jsonl");
 const BEHAVIORAL_CATEGORY = "behavioral";
@@ -125,15 +126,62 @@ function sortKeysDeep(value) {
 function jsonStringifySorted(value) {
     return JSON.stringify(sortKeysDeep(value));
 }
-function resolveLogPath(logPath) {
+function resolveLogPath(logPath, projectRoot) {
     if (logPath !== undefined && logPath !== null) {
-        return resolve(logPath);
+        return isAbsolute(logPath) ? resolve(logPath) : resolve(projectRoot, logPath);
     }
     const envPath = process.env.DEFT_EVENT_LOG;
     if (envPath !== undefined && envPath.length > 0) {
-        return resolve(envPath);
+        return isAbsolute(envPath) ? resolve(envPath) : resolve(projectRoot, envPath);
+    }
+    return resolve(projectRoot, DEFAULT_EVENT_LOG);
+}
+function isNestedUnder(parent, child) {
+    const rel = relative(resolve(parent), resolve(child));
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function assertPathComponentsNotSymlinks(projectDir, targetPath) {
+    const targetAbs = resolve(targetPath);
+    const projectAbs = resolve(projectDir);
+    let current = targetAbs;
+    const chain = [];
+    while (true) {
+        chain.unshift(current);
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    for (const segment of chain) {
+        let info;
+        try {
+            info = lstatSync(segment);
+        }
+        catch {
+            continue;
+        }
+        if (info.isSymbolicLink()) {
+            throw new ProjectionContainmentError(`projection write refused: ${segment} is a symlink on the write path`, { projectDir: projectAbs, targetPath: targetAbs, offendingPath: segment });
+        }
+    }
+}
+/** Refuse symlink write targets for project-owned and explicit event logs (#2766). */
+function assertEventLogTargetSafe(projectRoot, targetPath) {
+    if (isNestedUnder(projectRoot, targetPath)) {
+        assertWriteTargetSafe(projectRoot, targetPath);
+        return;
+    }
+    assertPathComponentsNotSymlinks(projectRoot, targetPath);
+}
+function appendLineNoFollow(target, line) {
+    const fd = openSync(target, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW, 0o644);
+    try {
+        writeSync(fd, Buffer.from(line, "utf8"));
+    }
+    finally {
+        closeSync(fd);
     }
-    return resolve(DEFAULT_EVENT_LOG);
 }
 function newEventId() {
     const wallNs = BigInt(Date.now()) * 1000000n;
@@ -160,14 +208,16 @@ export function emit(name, payload, options = {}) {
         detected_at: options.detectedAt ?? `${iso.slice(0, 19)}Z`,
         payload: { ...payload },
     };
-    const target = resolveLogPath(options.logPath);
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const target = resolveLogPath(options.logPath, projectRoot);
+    assertEventLogTargetSafe(projectRoot, target);
     mkdirSync(dirname(target), { recursive: true });
-    appendFileSync(target, `${jsonStringifySorted(record)}\n`, "utf8");
+    appendLineNoFollow(target, `${jsonStringifySorted(record)}\n`);
     return record;
 }
 /** Return all events from the log in emission order. */
 export function readEvents(logPath) {
-    const target = resolveLogPath(logPath);
+    const target = resolveLogPath(logPath, process.cwd());
     if (!existsSync(target)) {
         return [];
     }

package/dist/orphan-active/evaluate.d.ts

@@ -0,0 +1,25 @@
+import type { RunGhFn } from "../pr-protected-issues/types.js";
+export type OutputStream = "stdout" | "stderr" | "none";
+export interface OrphanActiveBrief {
+    readonly path: string;
+    readonly reason: string;
+}
+export interface EvaluateResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: OutputStream;
+    readonly orphans: readonly OrphanActiveBrief[];
+}
+export interface EvaluateOptions {
+    readonly quiet?: boolean;
+    readonly repo?: string | null;
+    readonly runGh?: RunGhFn;
+    readonly skipGh?: boolean;
+}
+/**
+ * Pure evaluator for orphaned active/running xBRIEF detection (#2321).
+ * Fails when active/ briefs with plan.status==running reference only closed
+ * issues and/or a merged PR — the stop-at:pr-open orphan signature.
+ */
+export declare function evaluate(projectRoot: string, options?: EvaluateOptions): EvaluateResult;
+//# sourceMappingURL=evaluate.d.ts.map