codiedev 0.9.56 → 0.10.0-beta.2

package/README.md

@@ -12,7 +12,7 @@ The CLI will prompt you for an API token (get one at https://codiedev.com/portal
 
 - **Claude Code** — `SessionEnd` hook in `~/.claude/settings.json`
 - **Codex** — `Stop` hook in `~/.codex/hooks.json`
-- **Cursor** — native session, backup, and capture hooks in `~/.cursor/hooks.json`
+- **Cursor** — native session, prompt-security, tool-security, backup, and capture hooks in `~/.cursor/hooks.json`
 - **OpenCode / Codie** — plugin in `~/.config/opencode/plugins/codiedev.js`
 
 Installed clients are wired automatically. The OpenCode adapter is staged even
@@ -51,9 +51,10 @@ Codex doesn't currently expose a `SessionEnd` event, so the hook runs on `Stop`
 
 ## Cursor note
 
-Cursor uses its native hook events for session start/end and stop-time backup.
-Cursor's `beforeSubmitPrompt` currently cannot inject dynamic context, so task-
-specific discovery remains unavailable there. Cursor sessions keep their source
+Cursor uses its native hook events for session start/end, prompt blocking,
+pre/post-tool security, and stop-time backup. Cursor's `beforeSubmitPrompt`
+cannot inject dynamic context today, so task-specific discovery is not claimed.
+Cursor sessions keep their source
 label and real transcript statistics through the shared capture pipeline.
 
 ## OpenCode note

package/dist/captureLog.d.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 export declare const CAPTURE_LOG_MAX_BYTES: number;
 export declare const CAPTURE_LOG_PATH: string;
 export interface CaptureLogEntry {
-    stage: "capture-finish" | "upload" | "upload-deferred" | "stderr" | "limit";
+    stage: "capture-finish" | "upload" | "upload-deferred" | "security" | "stderr" | "limit";
     sessionId: string | undefined;
     outcome: string;
     detail?: string;

package/dist/cli.js

@@ -33,6 +33,7 @@ const share_1 = require("./commands/share");
 const send_1 = require("./commands/send");
 const react_1 = require("./commands/react");
 const capture_1 = require("./commands/capture");
+const security_1 = require("./commands/security");
 const version_1 = require("./version");
 const HELP = `
 Codiedev CLI
@@ -43,7 +44,13 @@ Codiedev CLI
 
 Connect:
   codiedev connect                       Link Claude Code / Codex / Cursor to your org
-  codiedev doctor                        Verify your setup after connecting
+  codiedev doctor                        Verify setup, capture, and Agent Security
+  codiedev security pilot                Run safe synthetic policy checks
+  codiedev security inventory            Inventory MCPs, skills, hooks, plugins,
+                                         instructions, and editor extensions
+  codiedev security scan --deep          Run installed open-source scanners too
+  codiedev security sync                 Fetch administrator policy locally
+  codiedev security rollback --yes       Restore pre-update hook configuration
 
 Harness:
   codie                                  Launch the governed Codie harness.
@@ -451,6 +458,9 @@ async function main() {
             case "verify":
                 await (0, doctor_1.runDoctor)(rest);
                 return;
+            case "security":
+                await (0, security_1.runSecurityCommand)(rest);
+                return;
             case "push":
                 await (0, push_1.runPush)(rest);
                 return;

package/dist/codexLimitScan.d.ts

@@ -45,8 +45,6 @@ export interface SweepArgs {
     scanOptions?: ScanOptions;
     /** How many rollouts may actually be READ in one sweep. */
     maxScans?: number;
-    /** Stop starting new scans once this many ms have elapsed. */
-    deadlineMs?: number;
 }
 /**
  * Report every Codex block this machine has not reported yet. Returns how many

package/dist/codexLimitScan.js

@@ -382,20 +382,8 @@ function recordCodexLimitReported(filePath, at, statePath = exports.CODEX_LIMIT_
 // Candidates are listed generously and settled by one statSync each; only
 // files that actually changed cost a read. The budget therefore bounds work
 // without letting idle sessions bury an unreported block.
-//
-// The budget binds only on a COLD START, where nothing has been seen before,
-// so it must be big enough to finish that first pass. A budget of 8 silently
-// starved the older blocked rollouts on a real machine: 49 candidates in the
-// window, the newest 8 all unblocked, nothing reported. A full pass over
-// those 49 costs ~205ms — the backward scan stops at the marker rather than
-// reading each file to its cap — so the budget can afford to cover them.
 const DEFAULT_CANDIDATES = 200;
-const DEFAULT_MAX_SCANS = 64;
-// The budget bounds how MANY files are read; this bounds how LONG. A count is
-// not enough on a slow or network-mounted disk, and this runs on the user's
-// prompt clock. Whatever is not reached stays unrecorded, so the next prompt
-// picks it up rather than skipping it.
-const DEFAULT_DEADLINE_MS = 1_500;
+const DEFAULT_MAX_SCANS = 8;
 /**
  * Report every Codex block this machine has not reported yet. Returns how many
  * events were posted. Never throws — it runs inside a hook.
@@ -419,7 +407,6 @@ async function sweepCodexLimits(args) {
     const now = Date.now();
     const touched = {};
     let budget = args.maxScans ?? DEFAULT_MAX_SCANS;
-    const deadline = now + (args.deadlineMs ?? DEFAULT_DEADLINE_MS);
     const pending = [];
     for (const file of files) {
         const print = fingerprint(file);
@@ -430,7 +417,7 @@ async function sweepCodexLimits(args) {
         // it holds nothing new and does not spend the read budget.
         if (record && record.size === print.size && record.mtime === print.mtime)
             continue;
-        if (budget <= 0 || Date.now() >= deadline)
+        if (budget <= 0)
             break;
         budget -= 1;
         const hit = scanCodexRolloutForLimit(file, args.scanOptions);

package/dist/codie.js

@@ -53,6 +53,7 @@ const configDir_1 = require("./configDir");
 const codieLauncher_1 = require("./codieLauncher");
 const codieRuntime_1 = require("./codieRuntime");
 const codieRuntimeInstall_1 = require("./codieRuntimeInstall");
+const codieStartup_1 = require("./codieStartup");
 const upgradeNudge_1 = require("./upgradeNudge");
 function git(args) {
     const result = (0, child_process_1.spawnSync)("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
@@ -169,6 +170,120 @@ function installBrandWordmarkUnsafe(runtime) {
             (0, child_process_1.spawnSync)("codesign", ["--force", "--sign", "-", runtime], { stdio: "ignore" });
     }
 }
+async function runNonInteractive(runtime, runtimeArgs, env) {
+    const detached = process.platform !== "win32";
+    const child = (0, child_process_1.spawn)(runtime, runtimeArgs, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env,
+        detached,
+    });
+    if (child.stdin)
+        process.stdin.pipe(child.stdin);
+    const signalChild = (signal) => {
+        if (detached && child.pid) {
+            try {
+                process.kill(-child.pid, signal);
+                return;
+            }
+            catch {
+                // Fall back to the direct child if its process group already exited.
+            }
+        }
+        child.kill(signal);
+    };
+    const forwardInterrupt = () => signalChild("SIGINT");
+    const forwardTermination = () => signalChild("SIGTERM");
+    process.once("SIGINT", forwardInterrupt);
+    process.once("SIGTERM", forwardTermination);
+    return await new Promise((resolve, reject) => {
+        let blockReason;
+        const errorPrefixes = [Buffer.from("\x1b[91m\x1b[1mError:"), Buffer.from("Error: {")];
+        const retainedPrefixBytes = Math.max(...errorPrefixes.map((prefix) => prefix.length)) - 1;
+        // OpenCode's generic UnknownError and the adapter's private reason can be
+        // delivered in either order — and the generic block can arrive on stdout
+        // or stderr. Gate both streams by content, retaining only a possible final
+        // error block. Ordinary output stays streaming apart from the few bytes
+        // needed to recognize a split prefix.
+        const createOutputGate = (write) => {
+            let tail = Buffer.alloc(0);
+            let possibleError;
+            return {
+                push(chunk, blocked) {
+                    if (blocked) {
+                        if (possibleError)
+                            possibleError.push(Buffer.from(chunk));
+                        return;
+                    }
+                    if (possibleError) {
+                        possibleError.push(Buffer.from(chunk));
+                        return;
+                    }
+                    const combined = Buffer.concat([tail, chunk]);
+                    let errorStart = -1;
+                    for (const prefix of errorPrefixes) {
+                        const index = combined.indexOf(prefix);
+                        if (index >= 0 && (errorStart < 0 || index < errorStart))
+                            errorStart = index;
+                    }
+                    if (errorStart >= 0) {
+                        if (errorStart > 0)
+                            write(combined.subarray(0, errorStart));
+                        possibleError = [combined.subarray(errorStart)];
+                        tail = Buffer.alloc(0);
+                        return;
+                    }
+                    const flushBytes = Math.max(0, combined.length - retainedPrefixBytes);
+                    if (flushBytes > 0)
+                        write(combined.subarray(0, flushBytes));
+                    tail = combined.subarray(flushBytes);
+                },
+                finish(blocked) {
+                    if (tail.length > 0)
+                        write(tail);
+                    const heldError = possibleError ? Buffer.concat(possibleError).toString() : "";
+                    const genericBlockError = heldError.includes("UnknownError") &&
+                        heldError.includes("Unexpected server error");
+                    if (heldError && (!blocked || !genericBlockError))
+                        write(heldError);
+                },
+            };
+        };
+        const stdoutGate = createOutputGate((chunk) => process.stdout.write(chunk));
+        const stderrGate = createOutputGate((chunk) => process.stderr.write(chunk));
+        child.stdout?.on("data", (chunk) => {
+            stdoutGate.push(Buffer.from(chunk), Boolean(blockReason));
+        });
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString();
+            const reason = (0, codieLauncher_1.extractCodieSecurityBlock)(text);
+            if (reason) {
+                blockReason = reason;
+                signalChild("SIGTERM");
+                return;
+            }
+            stderrGate.push(Buffer.from(chunk), Boolean(blockReason));
+        });
+        child.once("error", (error) => {
+            if (child.stdin)
+                process.stdin.unpipe(child.stdin);
+            process.removeListener("SIGINT", forwardInterrupt);
+            process.removeListener("SIGTERM", forwardTermination);
+            reject(error);
+        });
+        child.once("close", (status) => {
+            if (child.stdin)
+                process.stdin.unpipe(child.stdin);
+            process.removeListener("SIGINT", forwardInterrupt);
+            process.removeListener("SIGTERM", forwardTermination);
+            stdoutGate.finish(Boolean(blockReason));
+            stderrGate.finish(Boolean(blockReason));
+            if (blockReason) {
+                console.error(`Codie Security blocked this action:\n${blockReason}`);
+            }
+            resolve(status);
+        });
+    });
+}
 async function main() {
     (0, codieRuntime_1.assertCodieNodeVersion)(process.versions.node);
     const connected = connectedCodiedevConfig();
@@ -186,6 +301,10 @@ async function main() {
         process.exitCode = update.status ?? 0;
         return;
     }
+    const policyRefresh = await (0, codieStartup_1.refreshCodieSecurityPolicy)(connected);
+    if (policyRefresh.status === "cached") {
+        console.error(`codie: security policy refresh failed; using the cached policy (${policyRefresh.error})`);
+    }
     const gatewayUrl = process.env.CODIEDEV_GATEWAY_URL || "https://gateway.codiedev.com/api/v1";
     const catalog = await (0, codieLauncher_1.fetchApprovedCatalog)({ baseUrl: gatewayUrl, key });
     const parsed = (0, codieLauncher_1.parseCodieArgs)(process.argv.slice(2));
@@ -196,11 +315,20 @@ async function main() {
     }
     (0, codieLauncher_1.validateCodieArgs)(parsed.args, catalog);
     const stateDir = (0, configDir_1.codiedevStateDir)();
-    const runtime = (0, codieRuntimeInstall_1.ensureCodieRuntimeBinary)({
+    const runtime = await (0, codieRuntimeInstall_1.ensureCodieRuntimeBinary)({
         resolve: () => (0, codieRuntime_1.resolveCodieRuntime)({
             env: process.env,
             stateDir,
             existsSync: (candidate) => fs.existsSync(candidate),
+            readInstalledVersion: (candidate) => {
+                try {
+                    const value = JSON.parse(fs.readFileSync(candidate, "utf8"));
+                    return typeof value.version === "string" ? value.version : null;
+                }
+                catch {
+                    return null;
+                }
+            },
             resolveBundled: () => {
                 try {
                     return require.resolve("opencode-ai/bin/opencode.exe");
@@ -211,6 +339,16 @@ async function main() {
             },
         }),
         install: (missing) => (0, codieRuntimeInstall_1.installCodieRuntimeOnDisk)(missing, stateDir),
+        confirmUpdate: async (outdated) => {
+            console.error("");
+            console.error(`Codie harness ${outdated.expectedVersion} is available (you're on ${outdated.currentVersion}).`);
+            if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                console.error("Restart `codie` in an interactive terminal to update the harness.");
+                console.error("");
+                return false;
+            }
+            return await (0, upgradeNudge_1.promptYesNo)("  Update the harness now? [y/N] ");
+        },
     });
     const metadataPlugin = (0, url_1.pathToFileURL)(assetPath("opencode-plugin.mjs")).href;
     const capturePlugin = (0, codieLauncher_1.resolveCapturePlugin)({ homeDir: os.homedir(), existsSync: fs.existsSync });
@@ -232,6 +370,13 @@ async function main() {
         OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
     };
     const runtimeArgs = (0, codieLauncher_1.withCodieWorkingDirectory)(parsed.args, process.cwd());
+    const nonInteractiveRun = runtimeArgs[0] === "run";
+    if (nonInteractiveRun)
+        env.CODIEDEV_SECURITY_BLOCK_OUTPUT = "marker";
+    if (nonInteractiveRun) {
+        process.exitCode = (await runNonInteractive(runtime, runtimeArgs, env)) ?? 1;
+        return;
+    }
     const result = (0, child_process_1.spawnSync)(runtime, runtimeArgs, { stdio: "inherit", env });
     if (result.error)
         throw result.error;

package/dist/codieLauncher.d.ts

@@ -2,6 +2,11 @@ export interface CatalogModel {
     id: string;
     name?: string;
 }
+export declare const CODIE_SECURITY_BLOCK_MARKER = "__CODIEDEV_SECURITY_BLOCK__";
+/** Extract the private adapter marker used to carry a local block reason
+ * across OpenCode's generic 500 boundary. The marker never contains prompt or
+ * tool input — only the deterministic policy reason. */
+export declare function extractCodieSecurityBlock(stderr: string): string | undefined;
 /**
  * Pin non-interactive runs to the directory where `codie` was launched.
  * OpenCode can reuse a previously-known project instance; without an explicit

package/dist/codieLauncher.js

@@ -42,7 +42,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HIDDEN_WORDMARK = exports.CODIEDEV_WORDMARK = exports.LEGACY_CODIEDEV_WORDMARK = exports.STOCK_WORDMARK = exports.BRAND_PLUGIN_SPEC = void 0;
+exports.HIDDEN_WORDMARK = exports.CODIEDEV_WORDMARK = exports.LEGACY_CODIEDEV_WORDMARK = exports.STOCK_WORDMARK = exports.BRAND_PLUGIN_SPEC = exports.CODIE_SECURITY_BLOCK_MARKER = void 0;
+exports.extractCodieSecurityBlock = extractCodieSecurityBlock;
 exports.withCodieWorkingDirectory = withCodieWorkingDirectory;
 exports.bareModel = bareModel;
 exports.buildCodieConfig = buildCodieConfig;
@@ -55,6 +56,7 @@ exports.validateCodieArgs = validateCodieArgs;
 const path = __importStar(require("path"));
 const url_1 = require("url");
 const DEFAULT_NAMES = {
+    "openai/gpt-5.6-luna": "GPT-5.6 Luna",
     "openai/gpt-5.3-codex": "GPT-5.3 Codex",
     "openai/gpt-5.2-codex": "GPT-5.2 Codex",
     "openai/gpt-5.1-codex-mini": "GPT-5.1 Codex Mini",
@@ -62,6 +64,26 @@ const DEFAULT_NAMES = {
     "z-ai/glm-5.2": "GLM 5.2 · Fireworks ZDR",
     "moonshotai/kimi-k2.7-code": "Kimi K2.7 Code · Fireworks ZDR",
 };
+exports.CODIE_SECURITY_BLOCK_MARKER = "__CODIEDEV_SECURITY_BLOCK__";
+/** Extract the private adapter marker used to carry a local block reason
+ * across OpenCode's generic 500 boundary. The marker never contains prompt or
+ * tool input — only the deterministic policy reason. */
+function extractCodieSecurityBlock(stderr) {
+    for (const line of stderr.split(/\r?\n/)) {
+        const markerIndex = line.indexOf(exports.CODIE_SECURITY_BLOCK_MARKER);
+        if (markerIndex < 0)
+            continue;
+        try {
+            const parsed = JSON.parse(line.slice(markerIndex + exports.CODIE_SECURITY_BLOCK_MARKER.length));
+            if (typeof parsed?.reason === "string" && parsed.reason.trim())
+                return parsed.reason.trim();
+        }
+        catch {
+            // Ignore malformed or foreign stderr and preserve the original runtime error.
+        }
+    }
+    return undefined;
+}
 /**
  * Pin non-interactive runs to the directory where `codie` was launched.
  * OpenCode can reuse a previously-known project instance; without an explicit

package/dist/codieRuntime.d.ts

@@ -1,4 +1,5 @@
 export declare const OPENCODE_RUNTIME_SPEC = "opencode-ai@1.18.4";
+export declare const OPENCODE_RUNTIME_VERSION: string;
 export declare const CODIE_MIN_NODE_MAJOR = 20;
 export type CodieRuntime = {
     kind: "ready";
@@ -8,12 +9,21 @@ export type CodieRuntime = {
     installDir: string;
     binary: string;
     spec: string;
+} | {
+    kind: "outdated";
+    installDir: string;
+    binary: string;
+    spec: string;
+    currentVersion: string;
+    expectedVersion: string;
 };
 export declare function codieRuntimeDir(stateDir: string): string;
-export declare function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }: {
+export declare function installedRuntimePackageJson(stateDir: string): string;
+export declare function resolveCodieRuntime({ env, stateDir, existsSync, readInstalledVersion, resolveBundled, }: {
     env: Record<string, string | undefined>;
     stateDir: string;
     existsSync: (candidate: string) => boolean;
+    readInstalledVersion?: (packageJson: string) => string | null;
     resolveBundled: () => string | null;
 }): CodieRuntime;
 export declare function assertCodieNodeVersion(version: string): void;

package/dist/codieRuntime.js

@@ -43,8 +43,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CODIE_MIN_NODE_MAJOR = exports.OPENCODE_RUNTIME_SPEC = void 0;
+exports.CODIE_MIN_NODE_MAJOR = exports.OPENCODE_RUNTIME_VERSION = exports.OPENCODE_RUNTIME_SPEC = void 0;
 exports.codieRuntimeDir = codieRuntimeDir;
+exports.installedRuntimePackageJson = installedRuntimePackageJson;
 exports.resolveCodieRuntime = resolveCodieRuntime;
 exports.assertCodieNodeVersion = assertCodieNodeVersion;
 const path = __importStar(require("path"));
@@ -52,6 +53,7 @@ const path = __importStar(require("path"));
 // recognizes byte-for-byte, so a floating version would silently regress the
 // terminal branding whenever OpenCode ships a new build.
 exports.OPENCODE_RUNTIME_SPEC = "opencode-ai@1.18.4";
+exports.OPENCODE_RUNTIME_VERSION = exports.OPENCODE_RUNTIME_SPEC.slice(exports.OPENCODE_RUNTIME_SPEC.lastIndexOf("@") + 1);
 // The harness needs 20; capture does not. package.json `engines` stays >=18 so
 // `codiedev connect` still installs for Node 18 users — this floor is enforced
 // at `codie` launch instead.
@@ -62,7 +64,10 @@ function codieRuntimeDir(stateDir) {
 function installedBinary(stateDir) {
     return path.join(codieRuntimeDir(stateDir), "node_modules", "opencode-ai", "bin", "opencode.exe");
 }
-function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }) {
+function installedRuntimePackageJson(stateDir) {
+    return path.join(codieRuntimeDir(stateDir), "node_modules", "opencode-ai", "package.json");
+}
+function resolveCodieRuntime({ env, stateDir, existsSync, readInstalledVersion, resolveBundled, }) {
     // 1. Explicit override — the air-gapped / pre-provisioned escape hatch.
     const override = env.CODIEDEV_OPENCODE_BINARY?.trim();
     if (override) {
@@ -78,8 +83,20 @@ function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }) {
         return { kind: "ready", binary: bundled };
     // 3. The lazily installed engine.
     const binary = installedBinary(stateDir);
-    if (existsSync(binary))
+    if (existsSync(binary)) {
+        const currentVersion = readInstalledVersion?.(installedRuntimePackageJson(stateDir)) ?? null;
+        if (currentVersion && currentVersion !== exports.OPENCODE_RUNTIME_VERSION) {
+            return {
+                kind: "outdated",
+                installDir: codieRuntimeDir(stateDir),
+                binary,
+                spec: exports.OPENCODE_RUNTIME_SPEC,
+                currentVersion,
+                expectedVersion: exports.OPENCODE_RUNTIME_VERSION,
+            };
+        }
         return { kind: "ready", binary };
+    }
     return { kind: "missing", installDir: codieRuntimeDir(stateDir), binary, spec: exports.OPENCODE_RUNTIME_SPEC };
 }
 function assertCodieNodeVersion(version) {

package/dist/codieRuntimeInstall.d.ts

@@ -1,9 +1,10 @@
 import { CodieRuntime } from "./codieRuntime";
+type InstallableCodieRuntime = Exclude<CodieRuntime, {
+    kind: "ready";
+}>;
 export declare function buildRuntimeInstallArgs(stagingDir: string, spec: string): string[];
 export interface InstallDeps {
-    runtime: Extract<CodieRuntime, {
-        kind: "missing";
-    }>;
+    runtime: InstallableCodieRuntime;
     makeStagingDir: () => string;
     run: (args: string[]) => {
         status: number | null;
@@ -15,13 +16,13 @@ export interface InstallDeps {
     log: (message: string) => void;
 }
 export declare function installCodieRuntime(deps: InstallDeps): void;
-export declare function ensureCodieRuntimeBinary({ resolve, install, }: {
+export declare function ensureCodieRuntimeBinary({ resolve, install, confirmUpdate, }: {
     resolve: () => CodieRuntime;
-    install: (runtime: Extract<CodieRuntime, {
-        kind: "missing";
-    }>) => void;
-}): string;
-export declare function installCodieRuntimeOnDisk(runtime: Extract<CodieRuntime, {
-    kind: "missing";
-}>, stateDir: string): void;
+    install: (runtime: InstallableCodieRuntime) => void;
+    confirmUpdate?: (runtime: Extract<CodieRuntime, {
+        kind: "outdated";
+    }>) => Promise<boolean>;
+}): Promise<string>;
+export declare function installCodieRuntimeOnDisk(runtime: InstallableCodieRuntime, stateDir: string): void;
 export declare function defaultStagingRoot(): string;
+export {};

package/dist/codieRuntimeInstall.js

@@ -98,10 +98,12 @@ function installCodieRuntime(deps) {
     }
 }
 // Resolve the engine, downloading it once if this is the first `codie` run.
-function ensureCodieRuntimeBinary({ resolve, install, }) {
+async function ensureCodieRuntimeBinary({ resolve, install, confirmUpdate = async () => false, }) {
     const runtime = resolve();
     if (runtime.kind === "ready")
         return runtime.binary;
+    if (runtime.kind === "outdated" && !(await confirmUpdate(runtime)))
+        return runtime.binary;
     install(runtime);
     return runtime.binary;
 }

package/dist/codieStartup.d.ts

@@ -0,0 +1,26 @@
+import type { AgentSurface, EndpointSecurityPolicy } from "./security";
+import type { AgentSecurityEntitlement } from "./securityFeature";
+export interface CodieStartupConfig extends AgentSecurityEntitlement {
+    backendUrl?: string;
+    token?: string;
+    companyId?: string;
+    deviceId?: string;
+}
+export type CodiePolicyRefreshResult = {
+    status: "disabled";
+} | {
+    status: "synced";
+    policy: EndpointSecurityPolicy;
+} | {
+    status: "cached";
+    error: string;
+};
+/** Refresh the endpoint policy before Codie hands the terminal to OpenCode.
+ * Enforcement remains available offline because hooks keep using the last
+ * verified company-scoped policy when this best-effort refresh cannot land. */
+export declare function refreshCodieSecurityPolicy(config: CodieStartupConfig, syncPolicy?: (config: {
+    backendUrl: string;
+    token: string;
+    companyId: string;
+    deviceId?: string;
+}, source?: AgentSurface) => Promise<EndpointSecurityPolicy>): Promise<CodiePolicyRefreshResult>;

package/dist/codieStartup.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshCodieSecurityPolicy = refreshCodieSecurityPolicy;
+const securityFeature_1 = require("./securityFeature");
+const securityPolicy_1 = require("./securityPolicy");
+/** Refresh the endpoint policy before Codie hands the terminal to OpenCode.
+ * Enforcement remains available offline because hooks keep using the last
+ * verified company-scoped policy when this best-effort refresh cannot land. */
+async function refreshCodieSecurityPolicy(config, syncPolicy = securityPolicy_1.syncEndpointSecurityPolicy) {
+    if (!(0, securityFeature_1.isAgentSecurityEnabled)(config))
+        return { status: "disabled" };
+    if (!config.backendUrl || !config.token || !config.companyId) {
+        return { status: "cached", error: "connected account details are incomplete" };
+    }
+    try {
+        const policy = await syncPolicy({
+            backendUrl: config.backendUrl,
+            token: config.token,
+            companyId: config.companyId,
+            ...(config.deviceId ? { deviceId: config.deviceId } : {}),
+        }, "codie-harness");
+        return { status: "synced", policy };
+    }
+    catch (error) {
+        return {
+            status: "cached",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/commands/doctor.js

@@ -45,6 +45,8 @@ const version_1 = require("../version");
 const upgradeNudge_1 = require("../upgradeNudge");
 const captureReadiness_1 = require("../captureReadiness");
 const captureLog_1 = require("../captureLog");
+const securityDoctor_1 = require("../securityDoctor");
+const securityFeature_1 = require("../securityFeature");
 const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
 const CLAUDE_INSTRUCTIONS_PATH = path.join(os.homedir(), ".claude", "CLAUDE.md");
 const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
@@ -482,6 +484,12 @@ async function runDoctor(_args) {
             detail: "not installed on this machine",
         });
     }
+    // Agent Security is part of installation health, not a separate setup
+    // concept. Keep `codiedev security doctor` as an alias for focused output,
+    // while the main doctor remains the one command users need to remember.
+    if ((0, securityFeature_1.isAgentSecurityEnabled)(config)) {
+        checks.push(...(0, securityDoctor_1.securityDoctorChecks)((0, securityDoctor_1.collectSecurityDoctorReport)(config.companyId)));
+    }
     // 8. gh / glab CLIs (optional — only needed for reverse-ticket from a
     // specific PR/MR URL; branch mode works without either).
     checks.push({

package/dist/commands/security.d.ts

@@ -0,0 +1 @@
+export declare function runSecurityCommand(args: string[]): Promise<void>;