codiedev 0.9.52 → 0.10.0-beta.1

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** — `sessionEnd` hook 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
@@ -49,6 +49,14 @@ container needs its own rule unless `~/.codiedev/config.json` is persisted.
 
 Codex doesn't currently expose a `SessionEnd` event, so the hook runs on `Stop` (fires after each assistant turn). The backend dedupes by `(company, session_id)` and replaces the stored transcript on re-upload so the latest turn's snapshot wins. Summarization happens once per session; subsequent turn uploads keep the raw transcript fresh but don't re-summarize (to avoid running up LLM cost).
 
+## Cursor note
+
+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
 
 OpenCode exposes session lifecycle events through plugins. Codiedev snapshots

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";
+    stage: "capture-finish" | "upload" | "upload-deferred" | "security" | "stderr";
     sessionId: string | undefined;
     outcome: string;
     detail?: string;

package/dist/cli.js

@@ -29,11 +29,11 @@ const createTicket_1 = require("./commands/createTicket");
 const doctor_1 = require("./commands/doctor");
 const search_1 = require("./commands/search");
 const library_1 = require("./commands/library");
-const post_1 = require("./commands/post");
 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,8 +43,14 @@ Codiedev CLI
   someone left off across sessions and providers.
 
 Connect:
-  codiedev connect                       Link Claude Code / Codex to your org
-  codiedev doctor                        Verify your setup after connecting
+  codiedev connect                       Link Claude Code / Codex / Cursor to your org
+  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.
@@ -98,9 +104,6 @@ Discovery:
                                          List artifacts in your workspace
 
 Feed:
-  codiedev post --title "<t>" --body "<b>" [--intent share|request_review|
-                request_expertise|link_share|rfc] [--filename <key>]
-                [--mention <name>]...    Publish to the team feed
   codiedev react <postId> <emoji>        Toggle a reaction on a feed post
 
 Privacy:
@@ -128,7 +131,7 @@ Other artifact types (rare — use the matching prefix):
 
 Skills (slash commands):
   Add 'name:' + 'description:' YAML frontmatter to any pushed file
-  and it shows up as /<name> in Claude Code / Codex. Filename
+  and it shows up as /<name> in Claude Code / Codex / Cursor. Filename
   prefix doesn't matter — frontmatter is the signal.
 
 Examples:
@@ -165,6 +168,8 @@ codiedev connect — link your agent CLI to Codiedev
     - ~/.claude/CLAUDE.md instructions   (teaches Claude the commands)
     - ~/.codex/hooks.json hook           (same, for Codex)
     - ~/.codex/AGENTS.md instructions    (same, for Codex)
+    - ~/.cursor/hooks.json hooks         (session, prompt, security, capture)
+    - ~/.cursor/rules/codiedev.mdc       (teaches Cursor the commands)
 
   Re-run anytime to swap accounts or refresh the instruction block.
 
@@ -367,7 +372,7 @@ Default path:
          # body...
     3. codiedev push portal-design.md
 
-It's now /portal-design in Claude Code / Codex.
+It's now /portal-design in Claude Code / Codex / Cursor.
 
 Filename prefix is irrelevant for skills — frontmatter is the only
 signal. The stored artifact type still follows the filename rule
@@ -385,7 +390,7 @@ email notifications when pinged.
 
 ## Agent-native
 
-If you use Claude Code or Codex, the agent already knows the commands —
+If you use Claude Code, Codex, or Cursor, the agent already knows the commands —
 'codiedev connect' installs instructions into your user-level config.
 Just say things like:
 
@@ -453,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;
@@ -503,9 +511,6 @@ async function main() {
             case "ls":
                 await (0, library_1.runLibrary)(rest);
                 return;
-            case "post":
-                await (0, post_1.runPost)(rest);
-                return;
             case "share":
                 await (0, share_1.runShare)(rest);
                 return;

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;
@@ -62,6 +63,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>;