codiedev 0.9.88 → 0.9.90

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

package/dist/cli.d.ts

@@ -6,7 +6,7 @@
  *   codiedev connect                   — link agent CLIs to your org
  *   codiedev push <file>               — author/update a spec/review/decision/etc.
  *   codiedev pull <key>                — fetch an artifact by filename key
- *   codiedev ping <user> "<msg>"       — send a message (optionally --with <key>)
+ *   codiedev ping <user> ["<msg>"]     — message and/or share (--with <key>)
  *   codiedev inbox                     — list pings (use --unread to filter)
  *   codiedev read <ping-id>            — mark read + show full message
  *   codiedev reply <ping-id> "<msg>"   — answer a ping in its thread

package/dist/cli.js

@@ -7,7 +7,7 @@
  *   codiedev connect                   — link agent CLIs to your org
  *   codiedev push <file>               — author/update a spec/review/decision/etc.
  *   codiedev pull <key>                — fetch an artifact by filename key
- *   codiedev ping <user> "<msg>"       — send a message (optionally --with <key>)
+ *   codiedev ping <user> ["<msg>"]     — message and/or share (--with <key>)
  *   codiedev inbox                     — list pings (use --unread to filter)
  *   codiedev read <ping-id>            — mark read + show full message
  *   codiedev reply <ping-id> "<msg>"   — answer a ping in its thread
@@ -103,11 +103,10 @@ Artifacts:
                                          Asks for confirmation; -y to skip.
 
 Messaging:
-  codiedev ping <user> "<msg>" [--with <key>] [--file <path>]
-                                         Send a message to a teammate
-  codiedev send <key> <user> ["<msg>"]   Share an artifact + ping in one step
-  codiedev share <key> <user> [--role read|edit]
-                                         Silently grant access (no notification)
+  codiedev ping <user> ["<msg>"] [--with <key>] [--edit] [--file <path>]
+                                         Message a teammate (emails them). --with
+                                         gives them access to an artifact; with
+                                         no message it's a silent share
   codiedev inbox [--unread] [--limit N]  Show messages
   codiedev read <ping-id>                Mark read + show full message
   codiedev reply <ping-id> "<msg>" [--file <path>]
@@ -280,10 +279,14 @@ codiedev pull — fetch an artifact
     codiedev pull spec-cart-clear.md | less
 `.trim(),
     ping: `
-codiedev ping — send a teammate a message, optionally attached to an artifact
+codiedev ping — send a teammate a message, an artifact, or both
 
   Usage:
-    codiedev ping <user> "<message>" [--with <artifact-key>] [--file <path>]
+    codiedev ping <user> ["<message>"] [--with <artifact-key>] [--edit] [--file <path>]
+
+  --with gives them read access to the artifact (--edit: edit access; only
+  the owner can give edit access or share a private skill). With no message,
+  it's a silent share: access only, no inbox entry, no email.
 
   <user> resolves to a teammate in your org by first name, full name,
   or email. Ambiguous matches return a list — retry with the full email.

package/dist/codie.js

@@ -176,6 +176,57 @@ 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) => {
+        child.stdout?.on("data", (chunk) => process.stdout.write(chunk));
+        child.stderr?.on("data", (chunk) => {
+            // The Codiedev plugin stopped a prompt with a key in it: print its
+            // reason plainly instead of the private marker line.
+            const text = chunk.toString("utf8");
+            if (!text.includes(codieLauncher_1.PROMPT_BLOCK_MARKER))
+                return process.stderr.write(chunk);
+            process.stderr.write(text.split(/\r?\n/).map((line) => (0, codieLauncher_1.promptBlockLine)(line) ?? line).join("\n"));
+        });
+        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);
+            resolve(status);
+        });
+    });
+}
 async function main() {
     (0, codieRuntime_1.assertCodieNodeVersion)(process.versions.node);
     if (!process.env.CODIEDEV_GATEWAY_KEY && !process.env.CODIEDEV_TOKEN) {
@@ -303,6 +354,10 @@ async function main() {
     };
     const runtimeArgs = (0, codieLauncher_1.withCodieWorkingDirectory)(parsed.args, process.cwd());
     const nonInteractiveRun = runtimeArgs[0] === "run";
+    // A run has no TUI to show a stopped prompt; the plugin hands the reason
+    // back on stderr instead (see runNonInteractive).
+    if (nonInteractiveRun)
+        env.CODIEDEV_PROMPT_BLOCK_OUTPUT = "marker";
     if (nonInteractiveRun) {
         // The TUI paints its own live status line from the same endpoint. A
         // non-interactive run has no TUI, so the budget arrives as two printed
@@ -315,10 +370,7 @@ async function main() {
             if (line)
                 console.error(line);
         }
-        const result = (0, child_process_1.spawnSync)(runtime, runtimeArgs, { stdio: "inherit", env });
-        if (result.error)
-            throw result.error;
-        process.exitCode = result.status === null ? 1 : result.status;
+        process.exitCode = (await runNonInteractive(runtime, runtimeArgs, env)) ?? 1;
         if (reportCost) {
             // The gateway books a request's cost after it has answered, so a poll
             // fired the instant the run closes can miss the last one.

package/dist/codieLauncher.d.ts

@@ -89,3 +89,6 @@ export declare function parseCodieArgs(argv: string[]): {
     overrides: Record<string, string>;
 };
 export declare function validateCodieArgs(args: string[], catalog: CatalogModel[]): void;
+export declare const PROMPT_BLOCK_MARKER = "__CODIEDEV_PROMPT_BLOCKED__";
+/** The reason on a marker line, or null for any other line. */
+export declare function promptBlockLine(line: string): string | null;

package/dist/codieLauncher.js

@@ -42,7 +42,7 @@ 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 = exports.USAGE_MODULE_PLACEHOLDER = void 0;
+exports.PROMPT_BLOCK_MARKER = exports.HIDDEN_WORDMARK = exports.CODIEDEV_WORDMARK = exports.LEGACY_CODIEDEV_WORDMARK = exports.STOCK_WORDMARK = exports.BRAND_PLUGIN_SPEC = exports.USAGE_MODULE_PLACEHOLDER = void 0;
 exports.usableModelCost = usableModelCost;
 exports.usableModelLimit = usableModelLimit;
 exports.withCodieWorkingDirectory = withCodieWorkingDirectory;
@@ -56,6 +56,7 @@ exports.resolveCapturePlugin = resolveCapturePlugin;
 exports.fetchApprovedCatalog = fetchApprovedCatalog;
 exports.parseCodieArgs = parseCodieArgs;
 exports.validateCodieArgs = validateCodieArgs;
+exports.promptBlockLine = promptBlockLine;
 const path = __importStar(require("path"));
 const url_1 = require("url");
 const harnessDirs_1 = require("./harnessDirs");
@@ -461,3 +462,17 @@ function validateCodieArgs(args, catalog) {
         }
     }
 }
+exports.PROMPT_BLOCK_MARKER = "__CODIEDEV_PROMPT_BLOCKED__";
+/** The reason on a marker line, or null for any other line. */
+function promptBlockLine(line) {
+    const at = line.indexOf(exports.PROMPT_BLOCK_MARKER);
+    if (at < 0)
+        return null;
+    try {
+        const reason = JSON.parse(line.slice(at + exports.PROMPT_BLOCK_MARKER.length)).reason;
+        return typeof reason === "string" && reason.trim() ? `\n${reason.trim()}` : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/ping.d.ts

@@ -1 +1,10 @@
-export declare function runPing(args: string[]): Promise<void>;
+import type { CodiedevConfig } from "../utils";
+export declare const PING_USAGE = "Usage: codiedev ping <user> [\"<message>\"] [--with <artifact-key>] [--edit] [--file <path>]";
+export declare function parsePingArgs(allArgs: string[]): {
+    to: string;
+    body: string;
+    subjectKey?: string;
+    edit: boolean;
+    files: string[];
+};
+export declare function runPing(args: string[], configOverride?: CodiedevConfig): Promise<void>;

package/dist/commands/ping.js

@@ -1,16 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PING_USAGE = void 0;
+exports.parsePingArgs = parsePingArgs;
 exports.runPing = runPing;
+// `codiedev ping <user> ["<message>"] [--with <artifact>] [--edit] [--file <path>]`
+// The one way to send a teammate something:
+//   message only            → inbox + email
+//   message + --with        → inbox + email, and they get access to the artifact
+//   --with, no message      → access only, no notification (what `share` did)
+// `send` and `share` are kept as aliases that route here.
 const shared_1 = require("./shared");
 const pingFiles_1 = require("./pingFiles");
-function parseArgs(allArgs) {
+const share_1 = require("./share");
+exports.PING_USAGE = 'Usage: codiedev ping <user> ["<message>"] [--with <artifact-key>] [--edit] [--file <path>]';
+function parsePingArgs(allArgs) {
     const { files, rest: args } = (0, pingFiles_1.takeFileArgs)(allArgs);
     let to;
     const positional = [];
     let subjectKey;
+    let edit = false;
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
-        if ((a === "--with" || a === "-w") && i + 1 < args.length) {
+        if (a === "--edit") {
+            edit = true;
+        }
+        else if ((a === "--with" || a === "-w") && i + 1 < args.length) {
             subjectKey = args[++i];
         }
         else if (a.startsWith("--with=")) {
@@ -20,26 +34,41 @@ function parseArgs(allArgs) {
             positional.push(a);
         }
     }
-    // A file can stand in for the message.
-    if (positional.length < 2 && !(positional.length === 1 && files.length > 0)) {
-        console.error("Usage: codiedev ping <user> \"<message>\" [--with <artifact-key>] [--file <path>]");
+    // A file can stand in for the message; --with alone shares without one.
+    if (positional.length < 2 && !(positional.length === 1 && (files.length > 0 || subjectKey))) {
+        console.error(exports.PING_USAGE);
+        process.exit(1);
+    }
+    if (edit && !subjectKey) {
+        console.error("--edit needs an artifact: --with <artifact-key>");
         process.exit(1);
     }
     to = positional[0];
     // Join remaining positionals in case the shell split the message on spaces
     // despite quoting (happens with some escape sequences).
     const body = (0, shared_1.stripQuotes)(positional.slice(1).join(" "));
-    return { to, body: body || (files.length ? "Sent a file." : ""), subjectKey, files };
+    return { to, body: body || (files.length ? "Sent a file." : ""), subjectKey, edit, files };
 }
-async function runPing(args) {
-    const { to, body, subjectKey, files } = parseArgs(args);
-    const config = (0, shared_1.requireConfig)();
+async function runPing(args, configOverride) {
+    const { to, body, subjectKey, edit, files } = parsePingArgs(args);
+    // Nothing to say, just access: a silent share.
+    if (!body && subjectKey) {
+        await (0, share_1.runShare)([subjectKey, to, "--role", edit ? "edit" : "read"], configOverride);
+        return;
+    }
+    const config = configOverride ?? (0, shared_1.requireConfig)();
     const start = Date.now();
     try {
         const attachmentIds = await (0, pingFiles_1.uploadOrExit)(config, files);
         const res = await (0, shared_1.apiRequest)("POST", "/api/cli/ping", {
             config,
-            body: { to, body, subjectKey, ...(attachmentIds.length ? { attachmentIds } : {}) },
+            body: {
+                to,
+                body,
+                subjectKey,
+                ...(subjectKey ? { grant: edit ? "edit" : "read" } : {}),
+                ...(attachmentIds.length ? { attachmentIds } : {}),
+            },
         });
         (0, shared_1.recordAgentEvent)(config, {
             tool: "codiedev_ping",

package/dist/commands/send.d.ts

@@ -1,2 +1,3 @@
 import type { CodiedevConfig } from "../utils";
+export declare function sendToPingArgs(args: string[]): string[] | null;
 export declare function runSend(args: string[], configOverride?: CodiedevConfig): Promise<void>;

package/dist/commands/send.js

@@ -1,67 +1,27 @@
 "use strict";
-// `codiedev send <filename> <recipient> [message]` — share an artifact AND
-// send a short message that lands in the teammate's inbox. The active-
-// handoff version of `codiedev share`. Use this when the user is actively
-// looping someone in.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToPingArgs = sendToPingArgs;
 exports.runSend = runSend;
+// `codiedev send <artifact> <recipient> ["<message>"]` — kept as an alias for
+// `codiedev ping <recipient> ["<message>"] --with <artifact>`. With a message
+// the teammate gets it in their inbox and by email plus read access; without
+// one it's a silent share.
+const ping_1 = require("./ping");
 const shared_1 = require("./shared");
-function parseArgs(args) {
+function sendToPingArgs(args) {
     const positionals = args.filter((a) => !a.startsWith("--"));
     const [filename, to, ...rest] = positionals;
-    if (!filename || !to) {
-        console.error('Usage: codiedev send <filename> <recipient> ["<message>"]');
-        process.exit(1);
-    }
+    if (!filename || !to)
+        return null;
     // Recombine remaining tokens — supports both quoted and unquoted messages.
-    const message = rest.length > 0 ? (0, shared_1.stripQuotes)(rest.join(" ")) : undefined;
-    return { filename, to, message };
+    const message = rest.length > 0 ? (0, shared_1.stripQuotes)(rest.join(" ")) : "";
+    return [to, ...(message ? [message] : []), "--with", filename];
 }
 async function runSend(args, configOverride) {
-    const parsed = parseArgs(args);
-    const config = configOverride ?? (0, shared_1.requireConfig)();
-    const start = Date.now();
-    try {
-        const body = {
-            filename: parsed.filename,
-            to: parsed.to,
-        };
-        if (parsed.message)
-            body.message = parsed.message;
-        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/send-to", {
-            config,
-            body,
-        });
-        (0, shared_1.recordAgentEvent)(config, {
-            tool: "codiedev_send_to",
-            ok: true,
-            latencyMs: Date.now() - start,
-        });
-        const who = res.recipient ? `${res.recipient.name} (${res.recipient.email})` : parsed.to;
-        if (parsed.message) {
-            console.log(`Sent ${parsed.filename} to ${who}.`);
-        }
-        else {
-            console.log(`Shared ${parsed.filename} with ${who} (no message).`);
-        }
-    }
-    catch (err) {
-        (0, shared_1.recordAgentEvent)(config, {
-            tool: "codiedev_send_to",
-            ok: false,
-            latencyMs: Date.now() - start,
-            error: err.message,
-        });
-        const body = err.body;
-        if (body && Array.isArray(body.candidates) && body.candidates.length > 0) {
-            console.error(`Recipient "${parsed.to}" is ambiguous. Candidates:`);
-            for (const c of body.candidates) {
-                console.error(`  - ${c.name} (${c.email})`);
-            }
-        }
-        else {
-            console.error(`Send failed: ${err.message}`);
-        }
+    const pingArgs = sendToPingArgs(args);
+    if (!pingArgs) {
+        console.error('Usage: codiedev send <artifact> <recipient> ["<message>"]  (same as: codiedev ping <recipient> ["<message>"] --with <artifact>)');
         process.exit(1);
     }
+    await (0, ping_1.runPing)(pingArgs, configOverride);
 }

package/dist/commands/share.js

@@ -1,7 +1,7 @@
 "use strict";
 // `codiedev share <filename> <recipient> [--role read|edit]` — silently
-// grant a teammate access to an artifact (no notification). Use
-// `codiedev send` instead when the user wants to actively loop someone in.
+// grant a teammate access to an artifact (no notification). Kept as an alias:
+// `codiedev ping <recipient> --with <filename> [--edit]` lands here too.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runShare = runShare;
 const shared_1 = require("./shared");

package/dist/hook.js

@@ -64,6 +64,7 @@ const copilotHooks_1 = require("./copilotHooks");
 const piHooks_1 = require("./piHooks");
 const cliSession_1 = require("./cliSession");
 const utils_2 = require("./utils");
+const promptGuard_1 = require("./promptGuard");
 // Pure builder for the discovery additionalContext. Returns null when there are
 // no matches. The suggested `codiedev pull` command carries the EXACT top key
 // (e.g. "pr-push.md") rather than a "<key>" placeholder — otherwise agents
@@ -597,6 +598,48 @@ async function main() {
     catch {
         process.exit(0);
     }
+    // Privacy exclusions suppress every Codiedev upload.
+    const captureIgnored = (0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput);
+    // Background refresh of the company's "stop prompts with a key" setting.
+    if (process.argv[2] === "prompt-guard-refresh") {
+        await (0, cliSession_1.ensureFreshToken)({ configPath: utils_2.CONFIG_PATH }).catch(() => undefined);
+        await (0, promptGuard_1.refreshPromptGuardPolicy)((0, utils_1.readConfig)());
+        process.exit(0);
+    }
+    // Stop a prompt with a key in it, when the company turned that on. Runs
+    // before discovery (which would send the prompt to the backend) and even
+    // where capture is excluded: it's local and never uploads the prompt.
+    const PROMPT_HOOKS = {
+        discover: "claude-code",
+        "discover-codex": "codex",
+        "discover-codie": "codie-harness",
+        "discover-copilot": "copilot",
+        "discover-pi": "pi",
+        "prompt-guard-cursor": "cursor",
+    };
+    const promptHarness = PROMPT_HOOKS[process.argv[2] ?? ""];
+    if (promptHarness) {
+        const guard = (0, promptGuard_1.checkPrompt)(hookInput.prompt, promptHarness, (0, promptGuard_1.readPromptGuardPolicy)());
+        // An ignored session makes no Codiedev request, not even this refresh.
+        if (!captureIgnored)
+            (0, promptGuard_1.maybeSpawnPromptGuardRefresh)({ connected: Boolean((0, utils_1.readConfig)()) });
+        if (guard.blocked) {
+            (0, captureLog_1.appendCaptureLog)({
+                stage: "prompt-guard",
+                sessionId: hookInput.session_id ?? "unknown",
+                outcome: "ok",
+                detail: `blocked harness=${promptHarness} rule=${guard.key.rule}`,
+            });
+            process.stdout.write(JSON.stringify(guard.response));
+            if (!captureIgnored)
+                await (0, promptGuard_1.reportPromptBlocked)((0, utils_1.readConfig)(), guard.key.rule, promptHarness);
+            process.exit(0);
+        }
+        if (promptHarness === "cursor") {
+            process.stdout.write(JSON.stringify({ continue: true }));
+            process.exit(0);
+        }
+    }
     // Local privacy boundary: every stdin-driven hook mode passes through this
     // check BEFORE prompt discovery, limit-event tails, SessionStart pings,
     // backup, self-heal, transcript reads, or detached dispatch. Ignored means
@@ -665,6 +708,8 @@ async function main() {
         (0, sync_1.maybeSpawnPackSync)({ connected: Boolean((0, utils_1.readConfig)()), cli: path.join(__dirname, "cli.js") });
         // Local session scrub of past sessions on this machine (hourly, detached).
         (0, localScrub_1.maybeSpawnLocalScrub)({ connected: Boolean((0, utils_1.readConfig)()), cwd: hookInput.cwd });
+        // Keep "stop prompts with a key" current before the first prompt.
+        (0, promptGuard_1.maybeSpawnPromptGuardRefresh)({ connected: Boolean((0, utils_1.readConfig)()) });
         const packNag = process.argv[2] === "session-start-opencode" || process.argv[2] === "session-start-pi" ? null : (0, sync_1.packNagLine)();
         // Claude Code adds SessionStart stdout to the session context.
         if (packNag && process.argv[2] === "session-start")
@@ -716,6 +761,8 @@ async function main() {
     }
     if (process.argv[2] === "capture-codex")
         (0, utils_1.ensureCodexLimitHookInstalled)();
+    if (/-opencode(?:-final)?$/.test(process.argv[2] ?? ""))
+        (0, utils_1.ensureOpenCodePluginCurrent)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
     // Read here, in the process the harness spawned: the detached capture child
     // is reparented once this exits and can no longer see who launched it.

package/dist/mcp.js

@@ -174,10 +174,10 @@ const TOOLS = [
     },
     {
         name: "codiedev_ping",
-        description: "Send a message to a teammate on Codiedev, optionally attached to a " +
-            "specific artifact. Use when the user asks to ping, ask, share with, " +
-            "or get feedback from a teammate by name (e.g. 'ping a teammate about " +
-            "this spec'). Recipients are resolved by first name, full name, or email " +
+        description: "Send a message to a teammate on Codiedev, optionally with an " +
+            "artifact (they also get read access to it). Use when the user asks to " +
+            "ping, ask, send something to, or get feedback from a teammate by name " +
+            "(e.g. 'send this spec to a teammate'). Recipients are resolved by first name, full name, or email " +
             "within the current org. They're notified by email and can reply " +
             "from their own agent.",
         inputSchema: {
@@ -194,8 +194,13 @@ const TOOLS = [
                 },
                 subjectKey: {
                     type: "string",
-                    description: "Optional filename key of an artifact the message is about " +
-                        "(e.g. 'spec-214.md'). Leaving blank sends a standalone ping.",
+                    description: "Optional filename key of an artifact to send (e.g. " +
+                        "'spec-214.md'). The teammate also gets read access to it. " +
+                        "Leaving blank sends a standalone ping.",
+                },
+                edit: {
+                    type: "boolean",
+                    description: "With subjectKey: give edit access instead of read (owner only).",
                 },
             },
             required: ["to", "body"],
@@ -245,7 +250,7 @@ const TOOLS = [
             "without sending a notification. Use when the user says 'share this " +
             "with a teammate' or 'give someone access', and doesn't want to surface " +
             "it as a message. If they want the teammate actively notified, use " +
-            "codiedev_send_to instead.",
+            "codiedev_ping with subjectKey instead.",
         inputSchema: {
             type: "object",
             properties: {
@@ -264,27 +269,6 @@ const TOOLS = [
             required: ["filename", "to"],
         },
     },
-    {
-        name: "codiedev_send_to",
-        description: "Grant access to an artifact AND send a short message to a " +
-            "teammate. Use when the user asks to 'send this to a teammate', 'ask " +
-            "someone to look at this', or 'share this with a teammate and tell them X'. " +
-            "This is the active handoff version of codiedev_share_with — the " +
-            "recipient gets a ping in their inbox.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                filename: { type: "string", description: "Artifact filename." },
-                to: { type: "string", description: "Teammate first name, full name, or email." },
-                message: {
-                    type: "string",
-                    description: "Optional short note to send with the share. If omitted, only " +
-                        "the grant is created (no ping).",
-                },
-            },
-            required: ["filename", "to"],
-        },
-    },
     {
         name: "codiedev_search",
         description: "Search the team's artifact library by natural-language query. Use " +
@@ -534,12 +518,13 @@ async function handlePing(args, config) {
     const to = asString(args.to);
     const body = asString(args.body);
     const subjectKey = asStringOrUndefined(args.subjectKey);
+    const grant = subjectKey ? (args.edit === true ? "edit" : "read") : undefined;
     if (!to)
         throw new Error("to required");
     if (!body)
         throw new Error("body required");
     try {
-        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/ping", { config, body: { to, body, subjectKey } });
+        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/ping", { config, body: { to, body, subjectKey, ...(grant ? { grant } : {}) } });
         return {
             content: [
                 {

package/dist/promptGuard.d.ts

@@ -0,0 +1,63 @@
+import { spawn as nodeSpawn } from "child_process";
+import { type ExtraRule } from "./scrub/promptRules";
+export type PromptHarness = "claude-code" | "codex" | "cursor" | "codie-harness" | "copilot" | "pi";
+export interface TokenFormat {
+    name: string;
+    source: string;
+    keyword?: string;
+}
+export interface PromptGuardPolicy {
+    blockPrompts: boolean;
+    formats: TokenFormat[];
+    fetchedAt: number;
+}
+export declare const REFRESH_MS: number;
+export interface PromptKey {
+    rule: string;
+    label: string;
+    hint: string;
+}
+export declare function keyLabel(rule: string): string;
+/** The company's own token formats as scrub rules; a bad one is skipped. */
+export declare function formatRules(formats: readonly TokenFormat[]): ExtraRule[];
+/** The first real key in a prompt, or null. */
+export declare function findPromptKey(prompt: string, formats?: readonly TokenFormat[], now?: number): PromptKey | null;
+/** What the person sees. Names the kind of key and its last four, says
+ *  nothing was sent, and how to do it instead. */
+export declare function blockMessage(key: PromptKey): string;
+/** The hook's stdout for each harness when it stops a prompt. */
+export declare function blockResponse(harness: PromptHarness, message: string): Record<string, unknown>;
+export declare function readPromptGuardPolicy(stateDir?: string): PromptGuardPolicy | null;
+export declare function writePromptGuardPolicy(policy: PromptGuardPolicy, stateDir?: string): void;
+interface GuardConfig {
+    token?: string;
+    backendUrl?: string;
+}
+/** Ask the server for the company's setting and cache it. On any failure the
+ *  last cached answer stays (and its age makes the next hook try again). */
+export declare function refreshPromptGuardPolicy(config: GuardConfig | null, fetchImpl?: typeof fetch, stateDir?: string, now?: number): Promise<PromptGuardPolicy | null>;
+/** Start a background refresh when the cached setting is missing or stale.
+ *  Stamps the cache's age first so a burst of hooks starts only one. */
+export declare function maybeSpawnPromptGuardRefresh(opts: {
+    connected: boolean;
+    stateDir?: string;
+    now?: number;
+    hookEntry?: string;
+    spawn?: typeof nodeSpawn;
+    force?: boolean;
+}): "spawned" | "fresh" | "disabled" | "error";
+export interface PromptCheck {
+    blocked: false;
+}
+export interface PromptBlocked {
+    blocked: true;
+    key: PromptKey;
+    message: string;
+    response: Record<string, unknown>;
+}
+/** Check one prompt against the cached setting. Never throws. */
+export declare function checkPrompt(prompt: string | undefined, harness: PromptHarness, policy: PromptGuardPolicy | null, now?: number): PromptCheck | PromptBlocked;
+/** Tell the server a prompt was stopped: the rule and harness only. Detached
+ *  and best-effort; a slow network never holds the prompt hook. */
+export declare function reportPromptBlocked(config: GuardConfig | null, rule: string, harness: PromptHarness, fetchImpl?: typeof fetch): Promise<void>;
+export {};