@deftai/directive-core 0.90.0 → 0.92.0

package/dist/init-deposit/hygiene.js

@@ -2,7 +2,13 @@
  * Scoped staging + installer-managed allowlist for TS-native init/update (#1453).
  *
  * Mirrors cmd/deft-install/hygiene.go + deposit.go installerManagedMatchers.
- * Refs #1576, #1453, #1430.
+ *
+ * CRITICAL (#1430 / #3030): the allowlist MUST honor the SPEC consumer-path
+ * denylist (`CONSUMER_GUARD_MUST_FIRE`). Consumer-authored PROJECT-DEFINITION
+ * and scope briefs are never installer-managed; if they reappear in
+ * `installerManagedMatchers()`, unit tests and deposit-time assert fail closed.
+ *
+ * Refs #1576, #1453, #1430, #3029, #3030.
  */
 import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, rmSync } from "node:fs";
@@ -15,6 +21,26 @@ export const CORE_GUARD_WORKFLOW_REL = ".github/workflows/deft-core-guard.yml";
 // The lifecycle dir names are identical across the legacy `vbrief/` tree and the
 // post-#2034 / #2110 `xbrief/` tree, so both allowlist families reuse this list.
 const VBRIEF_LIFECYCLE_DIRS = ["proposed", "pending", "active", "completed", "cancelled"];
+/**
+ * Consumer paths that MUST trip no-mixed-core-and-app when mixed with
+ * `.deft/core/**` (#1430 SPEC). These probe paths must never match
+ * `installerManagedMatchers()` / the deposited guard ERE.
+ *
+ * Legitimate installer scaffolding (xbrief/.deft-version, lifecycle .gitkeep,
+ * schemas/, migration/, xbrief.md) is NOT in this denylist — see #2277.
+ * Init may still *create* PROJECT-DEFINITION (#3013); create ≠ allowlist.
+ *
+ * Refs #3030, #3029, #1430.
+ */
+export const CONSUMER_GUARD_MUST_FIRE = [
+    "xbrief/PROJECT-DEFINITION.xbrief.json",
+    "vbrief/PROJECT-DEFINITION.vbrief.json",
+    // Representative consumer scope briefs (not scaffolding markers).
+    "xbrief/active/example-scope.xbrief.json",
+    "vbrief/active/example-scope.vbrief.json",
+    "xbrief/proposed/example-scope.xbrief.json",
+    "vbrief/pending/example-scope.vbrief.json",
+];
 /** Single source of truth for installer-managed paths (#1440 / #1576). */
 export function installerManagedMatchers() {
     return [
@@ -45,6 +71,10 @@ export function installerManagedMatchers() {
         // `deft update` framework-deposit PR trips no-mixed-core-and-app (#2277).
         { exact: "xbrief/.deft-version" },
         { exact: "xbrief/xbrief.md" },
+        // CRITICAL (#1430 / #3029 / #3030): do NOT allowlist consumer-authored
+        // PROJECT-DEFINITION (xbrief/ or vbrief/) or consumer scope briefs.
+        // Init may still seed PD (#3013); the seed is app-owned for guard classification
+        // so core+PD mixed PRs fail no-mixed-core-and-app. See CONSUMER_GUARD_MUST_FIRE.
         { prefix: "xbrief/schemas/" },
         { prefix: "xbrief/migration/" },
         ...VBRIEF_LIFECYCLE_DIRS.map((sub) => ({ exact: `xbrief/${sub}/.gitkeep` })),
@@ -58,12 +88,6 @@ function matcherToEre(matcher) {
         return `^${escapeEre(matcher.exact)}$`;
     return `^${escapeEre(matcher.prefix ?? "")}`;
 }
-/** POSIX ERE alternation embedded in the deposited deft-core-guard workflow. */
-export function installerManagedGuardEre() {
-    return installerManagedMatchers()
-        .map((matcher) => matcherToEre(matcher))
-        .join("|");
-}
 function matchesInstallerManaged(path, matchers) {
     for (const matcher of matchers) {
         if (matcher.exact && path === matcher.exact)
@@ -73,9 +97,90 @@ function matchesInstallerManaged(path, matchers) {
     }
     return false;
 }
+/** Consumer scope-brief filenames under lifecycle dirs (not scaffolding). */
+const CONSUMER_SCOPE_BRIEF_EXACT = /^(xbrief|vbrief)\/(proposed|pending|active|completed|cancelled)\/.+\.(x|v)brief\.json$/;
+/** PROJECT-DEFINITION exact paths (xbrief or legacy vbrief). */
+const CONSUMER_PROJECT_DEFINITION_EXACT = /^(xbrief|vbrief)\/PROJECT-DEFINITION\.(x|v)brief\.json$/;
+/**
+ * Prefixes that would exempt entire consumer lifecycle trees or the whole
+ * xbrief/vbrief tree — never installer-managed (#1430).
+ */
+const FORBIDDEN_CONSUMER_PREFIXES = new Set([
+    "xbrief/",
+    "vbrief/",
+    ...VBRIEF_LIFECYCLE_DIRS.flatMap((sub) => [`xbrief/${sub}/`, `vbrief/${sub}/`]),
+]);
+/**
+ * Fail closed when the installer-managed allowlist would exempt consumer
+ * PROJECT-DEFINITION or scope briefs (#3030 / #1430). Pure over `matchers` so
+ * tests can inject a bad matcher without mutating production state.
+ *
+ * Checks both:
+ * 1. Explicit probe paths in {@link CONSUMER_GUARD_MUST_FIRE}
+ * 2. Structural patterns (any exact consumer scope brief / PD; forbidden prefixes)
+ *    so an unlisted `xbrief/active/another-scope.xbrief.json` matcher still fails.
+ */
+export function assertInstallerAllowlistHonors1430(matchers = installerManagedMatchers()) {
+    for (const path of CONSUMER_GUARD_MUST_FIRE) {
+        if (matchesInstallerManaged(path, matchers)) {
+            throw new Error(`#1430 violation: ${path} must not be installer-managed (SPEC consumer denylist; see CONSUMER_GUARD_MUST_FIRE / #3030)`);
+        }
+    }
+    for (const matcher of matchers) {
+        if (matcher.exact) {
+            if (CONSUMER_PROJECT_DEFINITION_EXACT.test(matcher.exact) ||
+                CONSUMER_SCOPE_BRIEF_EXACT.test(matcher.exact)) {
+                throw new Error(`#1430 violation: exact matcher ${matcher.exact} must not be installer-managed (consumer brief denylist / #3030)`);
+            }
+        }
+        if (matcher.prefix) {
+            const normalized = matcher.prefix.endsWith("/") ? matcher.prefix : `${matcher.prefix}/`;
+            if (FORBIDDEN_CONSUMER_PREFIXES.has(normalized)) {
+                throw new Error(`#1430 violation: prefix matcher ${matcher.prefix} must not cover consumer brief trees (#3030)`);
+            }
+        }
+    }
+}
+/** POSIX ERE alternation embedded in the deposited deft-core-guard workflow. */
+export function installerManagedGuardEre() {
+    const matchers = installerManagedMatchers();
+    // Refuse to emit a guard workflow that would exempt consumer denylist paths.
+    assertInstallerAllowlistHonors1430(matchers);
+    return matchers.map((matcher) => matcherToEre(matcher)).join("|");
+}
 export function isInstallerManagedPath(path) {
     return matchesInstallerManaged(path, installerManagedMatchers());
 }
+/**
+ * TS twin of Go `classifyChangedPaths` / deposited shell guard (#1430).
+ * Core = `.deft/core/**`; installer-managed = allowlist; app = everything else.
+ * Guard fails iff both core and app are non-empty.
+ */
+export function classifyMixedCoreAndApp(changedPaths, matchers = installerManagedMatchers()) {
+    const core = [];
+    const installerManaged = [];
+    const app = [];
+    for (const raw of changedPaths) {
+        const path = raw.replace(/\\/g, "/");
+        if (!path)
+            continue;
+        if (path === ".deft/core" || path.startsWith(".deft/core/")) {
+            core.push(path);
+        }
+        else if (matchesInstallerManaged(path, matchers)) {
+            installerManaged.push(path);
+        }
+        else {
+            app.push(path);
+        }
+    }
+    return {
+        core,
+        installerManaged,
+        app,
+        wouldFail: core.length > 0 && app.length > 0,
+    };
+}
 export function frameworkStagePaths(projectDir, deftDir, options = {}) {
     const paths = [];
     const seen = new Set();

package/dist/init-deposit/init-deposit.d.ts

@@ -34,6 +34,11 @@ export declare function userConfigDir(): string;
 export declare function createUserConfigDir(io: InitDepositIo): string;
 export declare function buildInstallSummaryJson(result: InitDepositResult, options: InitDepositArgs): Record<string, unknown>;
 export declare function printNextSteps(result: InitDepositResult, io: InitDepositIo): void;
+/**
+ * Ensure a minimal render-ready PROJECT-DEFINITION exists after lifecycle dirs
+ * are deposited (#3013 / epic #3009). Idempotent: never overwrites existing identity.
+ */
+export declare function seedMinimalProjectDefinition(projectDir: string, io: InitDepositIo): boolean;
 export declare function runInitDeposit(args: InitDepositArgs, io: InitDepositIo, seams?: InitDepositSeams): Promise<InitDepositResult>;
 export interface RunInitDepositCliOptions extends InitDepositArgs {
     readonly writeOut: (text: string) => void;

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

@@ -7,12 +7,14 @@
  */
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir, platform } from "node:os";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { assertDepositContained } from "../deposit/contain.js";
 import { copyTree } from "../deposit/copy-tree.js";
 import { prunePythonArtifactsFromDeposit } from "../deposit/python-free.js";
 import { resolveInstalledContentRoot } from "../deposit/resolve-content.js";
 import { readCorePackageVersion } from "../engine-version.js";
+import { renderProjectDefinition } from "../render/project-render.js";
+import { removeStaleMigratedFrameworkNarrative } from "../xbrief-migrate/migrate-project.js";
 import { writeAgentHookDeposit } from "./agent-hooks.js";
 import { ensureInitGitignoreLines, reconstituteDepositFromContent } from "./gitignore.js";
 import { depositStagePaths, printCommitGuidance } from "./hygiene.js";
@@ -20,6 +22,7 @@ import { buildLegacyRefusalJson, buildLegacyRefusalMessage, detectLegacyLayout,
 import { printMigrateNudgeIfNeeded } from "./migrate.js";
 import { ensurePrettierIgnoreLines } from "./prettierignore.js";
 import { CANONICAL_INSTALL_ROOT, depositNeutralization, ensureTaskfile, writeAgentsMd, writeAgentsSkills, writeConsumerGitHooks, writeConsumerVbrief, writeInstallManifest, } from "./scaffold.js";
+import { syncBareVersionMarker } from "./xbrief-projections.js";
 export function parseInitArgv(canonicalArgv, userArgv = []) {
     const args = [...canonicalArgv, ...userArgv];
     let projectDir = process.cwd();
@@ -113,10 +116,36 @@ export function printNextSteps(result, io) {
     io.printf(`  1. Open your AI coding assistant in ${result.projectDir}\n`);
     io.printf("  2. Deft skill auto-discovery is partially implemented — if your agent doesn't\n");
     io.printf('     start setup automatically, tell it: "Use AGENTS.md"\n');
-    io.printf("  3. On first session, the agent will guide you through creating USER.md and PROJECT-DEFINITION.vbrief.json\n");
+    io.printf("  3. On first session, the agent will guide you through USER.md (if missing).\n");
+    io.printf("  4. PROJECT-DEFINITION is seeded at init (#3013) — run `task project:render` once to refresh items from lifecycle folders; do not multi-turn invent project identity.\n");
     printMigrateNudgeIfNeeded(result.projectDir, io);
     io.printf("\n");
 }
+/**
+ * Ensure a minimal render-ready PROJECT-DEFINITION exists after lifecycle dirs
+ * are deposited (#3013 / epic #3009). Idempotent: never overwrites existing identity.
+ */
+export function seedMinimalProjectDefinition(projectDir, io) {
+    const xbriefDir = join(projectDir, "xbrief");
+    const legacyDir = join(projectDir, "vbrief");
+    const root = existsSync(xbriefDir) ? xbriefDir : existsSync(legacyDir) ? legacyDir : null;
+    if (root === null) {
+        return false;
+    }
+    const isXbrief = basename(root) === "xbrief";
+    const projectDefPath = join(root, isXbrief ? "PROJECT-DEFINITION.xbrief.json" : "PROJECT-DEFINITION.vbrief.json");
+    if (existsSync(projectDefPath)) {
+        io.printf("PROJECT-DEFINITION already present — leaving identity intact (#3013).\n");
+        return false;
+    }
+    const [ok, message] = renderProjectDefinition(root);
+    if (ok) {
+        io.printf(`${message} (minimal seed for one-shot project:render; #3013)\n`);
+        return true;
+    }
+    io.printf(`PROJECT-DEFINITION seed skipped: ${message}\n`);
+    return false;
+}
 export async function runInitDeposit(args, io, seams = {}) {
     const projectDir = args.projectDir;
     const deftDir = join(projectDir, CANONICAL_INSTALL_ROOT);
@@ -154,6 +183,12 @@ export async function runInitDeposit(args, io, seams = {}) {
     const skillsCreated = writeAgentsSkills(projectDir, io);
     await depositNeutralization(projectDir, io);
     await writeConsumerVbrief(projectDir, deftDir, io);
+    seedMinimalProjectDefinition(projectDir, io);
+    // Seeding PROJECT-DEFINITION.xbrief.json makes resolveLifecycleRoot succeed.
+    // Align the same consumer derivatives update repairs (#2595 / #2806) so
+    // init + git add -A is already clean under core.autocrlf=true (#2118 / #3013).
+    syncBareVersionMarker(projectDir, version);
+    removeStaleMigratedFrameworkNarrative(projectDir);
     writeConsumerGitHooks(projectDir, deftDir, io, seams.gitHooks);
     writeAgentHookDeposit(projectDir, io);
     let taskfileWired = false;

package/dist/init-deposit/scaffold.js

@@ -14,7 +14,7 @@ import { assertDestinationNotSymlink, ProjectionContainmentError, } from "../fs/
 import { agentsRefreshPlan } from "../platform/agents-md.js";
 import { MIGRATED_ARTIFACT_DIR } from "../xbrief-migrate/constants.js";
 import { CANONICAL_INSTALL_ROOT } from "./constants.js";
-import { installerManagedGuardEre } from "./hygiene.js";
+import { assertInstallerAllowlistHonors1430, installerManagedGuardEre } from "./hygiene.js";
 import { syncConsumerXbriefSchemas } from "./xbrief-projections.js";
 export { CANONICAL_INSTALL_ROOT };
 export const CORE_GLOB = ".deft/core/**";
@@ -632,6 +632,8 @@ export function mergeCoreGuardWorkflowRefresh(existing, desired) {
     return desired.slice(0, idx) + existingCheckout + desired.slice(idx + desiredCheckout.length);
 }
 function coreGuardWorkflowContent() {
+    // Fail closed before emitting guard ERE if allowlist violates #1430 denylist (#3030).
+    assertInstallerAllowlistHonors1430();
     const baseSha = githubActionsExpr("github.event.pull_request.base.sha");
     const headSha = githubActionsExpr("github.event.pull_request.head.sha");
     return ("name: deft-core-guard\n\n" +

package/dist/intake/github-auth-modes.d.ts

@@ -1,4 +1,4 @@
-import { type CompletedProcess } from "../scm/call.js";
+import type { CompletedProcess } from "../scm/call.js";
 import { probeRuntimeCapabilities, type RuntimeCapabilityReport } from "./platform-capabilities.js";
 export declare const GITHUB_AUTH_MODE_INJECTED_TOKEN = "injected-token";
 export declare const GITHUB_AUTH_MODE_HOST_GH = "host-gh";

package/dist/intake/github-auth-modes.js

@@ -1,4 +1,4 @@
-import { call } from "../scm/call.js";
+import { spawnSync } from "node:child_process";
 import { pyRepr } from "../scm/py-format.js";
 import { getPlatformCapabilities, probeRuntimeCapabilities, RUNTIME_MODE_CLOUD_HEADLESS, RUNTIME_MODE_CURSOR_NATIVE_SANDBOX, } from "./platform-capabilities.js";
 export const GITHUB_AUTH_MODE_INJECTED_TOKEN = "injected-token";
@@ -37,9 +37,31 @@ export function inferGithubAuthMode(runtimeReport) {
     }
     return GITHUB_AUTH_MODE_HOST_GH;
 }
+/**
+ * Prefer live `gh` for auth/API validation. Do not route through scm.call /
+ * BINARY_PREFERENCE (ghx-first): ghx is a cached GET proxy and rejects multi-arg
+ * `api user --jq .login` forms used here (#2275 Greptile P1 / #954).
+ */
 function defaultRunGh(args, environ) {
-    const verb = args[0];
-    return call("github-issue", verb, args.slice(1), { env: environ, timeout: 30 });
+    const binary = "gh";
+    try {
+        const result = spawnSync(binary, [...args], {
+            env: environ,
+            encoding: "utf8",
+            timeout: 30_000,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return {
+            args: [binary, ...args],
+            returncode: result.status ?? 1,
+            stdout: typeof result.stdout === "string" ? result.stdout : "",
+            stderr: typeof result.stderr === "string" ? result.stderr : "",
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { args: [binary, ...args], returncode: 1, stdout: "", stderr: message };
+    }
 }
 function splitRepo(repo) {
     const idx = repo.indexOf("/");

package/dist/intake/issue-ingest-cli.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
+import { ScmStubError } from "../scm/errors.js";
+import { requireScmReady } from "../scm/readiness.js";
 import { issueIngestMain } from "./issue-ingest.js";
 function parseArgs(argv) {
     const out = {};
@@ -25,6 +27,17 @@ function parseArgs(argv) {
     return out;
 }
 export function mainEntry(argv = process.argv.slice(2)) {
+    // #2275: fail loud when gh/auth is missing in this execution env.
+    try {
+        requireScmReady();
+    }
+    catch (err) {
+        if (err instanceof ScmStubError) {
+            process.stderr.write(`error: ${err.message}\n`);
+            return 2;
+        }
+        throw err;
+    }
     return issueIngestMain(parseArgs(argv));
 }
 if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {

package/dist/intake/reconcile-issues-cli.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
+import { ScmStubError } from "../scm/errors.js";
+import { requireScmReady } from "../scm/readiness.js";
 import { reconcileMain } from "./reconcile-issues.js";
 function parseArgs(argv) {
     const out = {};
@@ -23,6 +25,17 @@ function parseArgs(argv) {
     return out;
 }
 export function mainEntry(argv = process.argv.slice(2)) {
+    // #2275: fail loud when gh/auth is missing in this execution env.
+    try {
+        requireScmReady();
+    }
+    catch (err) {
+        if (err instanceof ScmStubError) {
+            process.stderr.write(`error: ${err.message}\n`);
+            return 2;
+        }
+        throw err;
+    }
     return reconcileMain(parseArgs(argv));
 }
 if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {

package/dist/orchestration/probe-session.d.ts

@@ -36,7 +36,11 @@ export declare function detectGitBranch(projectRoot: string, execGit?: (args: st
 }): string;
 /** Read probe session from project root. */
 export declare function readSession(projectRoot: string): ProbeSession | null;
-/** Atomically persist session to .deft/probe-session.json. */
+/**
+ * Atomically persist session to .deft/probe-session.json.
+ * #3042: contain against projectRoot; refuse escaping `.deft` symlink parents
+ * (no bare open/write/rename).
+ */
 export declare function writeSession(projectRoot: string, session: ProbeSession): string;
 export declare function startSession(projectRoot: string, options: {
     target: string;

package/dist/orchestration/probe-session.js

@@ -3,8 +3,10 @@
  */
 import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { closeSync, existsSync, fdatasyncSync, mkdirSync, openSync, readFileSync, renameSync, writeSync, } from "node:fs";
+import { existsSync, readFileSync, renameSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 export const SCHEMA_VERSION = 1;
 export const SESSION_RELPATH = [".deft", "probe-session.json"];
 export const STATE_INTERROGATE = "interrogate";
@@ -188,11 +190,16 @@ export function readSession(projectRoot) {
         completed_at: completedAt,
     };
 }
-/** Atomically persist session to .deft/probe-session.json. */
+/**
+ * Atomically persist session to .deft/probe-session.json.
+ * #3042: contain against projectRoot; refuse escaping `.deft` symlink parents
+ * (no bare open/write/rename).
+ */
 export function writeSession(projectRoot, session) {
-    const sessionFile = sessionPath(projectRoot);
-    mkdirSync(join(projectRoot, ".deft"), { recursive: true });
-    const tmpName = join(projectRoot, ".deft", `.probe-session.${randomBytes(8).toString("hex")}.json.tmp`);
+    const root = resolve(projectRoot);
+    const sessionFile = sessionPath(root);
+    assertWriteTargetSafe(root, sessionFile);
+    const tmpName = join(root, ".deft", `.probe-session.${randomBytes(8).toString("hex")}.json.tmp`);
     const sortedPayload = sessionToDict(session);
     const sortedKeys = Object.keys(sortedPayload).sort();
     const sortedObj = {};
@@ -200,20 +207,24 @@ export function writeSession(projectRoot, session) {
         sortedObj[k] = sortedPayload[k];
     }
     const finalContent = `${JSON.stringify(sortedObj, null, 2)}\n`;
-    const fd = openSync(tmpName, "w");
     try {
-        writeSync(fd, finalContent, undefined, "utf8");
+        containedWrite({
+            root,
+            target: tmpName,
+            data: finalContent,
+            mode: "create",
+        });
+        renameSync(tmpName, sessionFile);
+    }
+    catch (err) {
         try {
-            fdatasyncSync(fd);
+            rmSync(tmpName, { force: true });
         }
         catch {
-            // best effort
+            /* best-effort cleanup */
         }
+        throw err;
     }
-    finally {
-        closeSync(fd);
-    }
-    renameSync(tmpName, sessionFile);
     return sessionFile;
 }
 export function startSession(projectRoot, options) {

package/dist/platform/agents-md.js

@@ -324,7 +324,7 @@ export function applyAgentsRefresh(projectRoot, options = {}, seams = {}, lockDe
             const writable = AGENTS_REFRESH_WRITABLE_STATES.has(state) && typeof newContent === "string";
             return { state, path, wrote: false, writable };
         }
-        atomicWriteText(path, newContent);
+        atomicWriteText(path, newContent, { projectRoot });
         return { state, path, wrote: true, writable: true };
     }, lockDeps);
 }

package/dist/policy/deft-directive-disable.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Temporary test/local kill-switch for Directive enforcement (#3039).
+ *
+ * Presence of root `.deft-directive-disable` means Directive **enforcement** is
+ * OFF (hooks, session ritual, automation) while the deposit may remain — **only
+ * when the file is not tracked by git**. A committed flag is misconfig: doctor
+ * warns and enforcement stays ON (repository-controlled content must not disable
+ * hooks for downstream clones).
+ *
+ * Distinct from `.no-deft-directive` (#2926 permanent opt-out): flag+deposit is
+ * **not** inconsistent here.
+ *
+ * Product choices (v1):
+ * - Flag is **root-only** (workspace root the tool opened).
+ * - Flag **must be gitignored** (canonical baseline); committed flag → doctor
+ *   warns and does **not** short-circuit enforcement.
+ * - Deposit presence is **OK**.
+ * - Full re-enable requires: delete the file **and** start a **new** agent session.
+ * - Precedence: active kill-switch first, then `.no-deft-directive`, else normal.
+ */
+/** Canonical root-only filename (lowercase). Presence = candidate flag. */
+export declare const DEFT_DIRECTIVE_DISABLE_FLAG_NAME = ".deft-directive-disable";
+/** Gitignore entry the deposit must ensure (same as flag name). */
+export declare const DEFT_DIRECTIVE_DISABLE_GITIGNORE_LINE = ".deft-directive-disable";
+/**
+ * Canonical recovery message when Directive is disabled by the test kill-switch.
+ * Surfaces (doctor, agent, CLI, hooks) share this wording.
+ */
+export declare const DEFT_DIRECTIVE_DISABLE_RECOVERY_MESSAGE: string;
+/** One-line summary for log lines and short CLI output. */
+export declare const DEFT_DIRECTIVE_DISABLE_ONE_LINE = "Directive disabled via `.deft-directive-disable` (test/local kill-switch; deposit OK)";
+/** Doctor/status label when the kill-switch is active (local / untracked). */
+export declare const DEFT_DIRECTIVE_DISABLE_STATUS: "disabled-test-kill-switch";
+/**
+ * Warning when the kill-switch file is tracked by git (should be gitignored).
+ * Tracked flags do **not** disable enforcement.
+ */
+export declare const DEFT_DIRECTIVE_DISABLE_TRACKED_WARNING = "Misconfig: `.deft-directive-disable` is tracked by git. The flag must be gitignored (local kill-switch only). Untrack it and ensure `.gitignore` covers the path. Enforcement is NOT disabled while the flag is tracked.";
+export interface DeftDirectiveDisableSeams {
+    readonly isFile?: (path: string) => boolean;
+    readonly isDir?: (path: string) => boolean;
+    /** Return true when `git ls-files` lists the flag (tracked). */
+    readonly isGitTracked?: (projectRoot: string, relPath: string) => boolean;
+    /** Skip tracked probe + cache (tests / doctor full re-check). */
+    readonly skipTrackedCache?: boolean;
+}
+export interface DeftDirectiveDisableState {
+    readonly present: boolean;
+    readonly flagPath: string;
+    readonly depositPresent: boolean;
+    /**
+     * True when the flag file is tracked by git (misconfig — should be gitignored).
+     * Always false when the flag is absent or when the probe cannot run.
+     */
+    readonly trackedByGit: boolean;
+    /**
+     * True when the kill-switch is **active** for enforcement short-circuit:
+     * present and **not** tracked by git.
+     */
+    readonly active: boolean;
+}
+/** Absolute path to the root kill-switch flag file. */
+export declare function deftDirectiveDisableFlagPath(projectRoot: string): string;
+/**
+ * Detect root `.deft-directive-disable`. Presence is file-existence only
+ * (empty or short comment OK). Deposit presence is reported but never treated
+ * as inconsistent (#3039 vs #2926).
+ *
+ * Enforcement short-circuit uses `state.active` (present && !trackedByGit).
+ */
+export declare function detectDeftDirectiveDisable(projectRoot: string, seams?: DeftDirectiveDisableSeams): DeftDirectiveDisableState;
+/**
+ * True when the local (untracked) kill-switch is active for enforcement
+ * short-circuit. Tracked flags return false so hooks stay enforced.
+ */
+export declare function isDeftDirectiveDisableActive(projectRoot: string, seams?: DeftDirectiveDisableSeams): boolean;
+/**
+ * Full operator-facing message for the kill-switch, optionally combined with
+ * permanent opt-out when both flags are present.
+ */
+export declare function formatDeftDirectiveDisableMessage(options?: {
+    readonly permanentOptOutAlsoPresent?: boolean;
+    readonly trackedByGit?: boolean;
+    readonly oneLine?: boolean;
+}): string;
+//# sourceMappingURL=deft-directive-disable.d.ts.map