codiedev 0.9.51 → 0.10.0-beta.1

package/dist/limitEvent.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyLimitKind = classifyLimitKind;
 exports.parseLimitEventFromTranscript = parseLimitEventFromTranscript;
+exports.parseCodexLimitEventFromTranscript = parseCodexLimitEventFromTranscript;
 exports.tailForLimitEvent = tailForLimitEvent;
 function classifyLimitKind(text) {
     const t = text.toLowerCase();
@@ -50,6 +51,63 @@ function parseLimitEventFromTranscript(transcript) {
     }
     return found;
 }
+function codexLimitKind(reason, spendControlReached) {
+    if (spendControlReached || reason.startsWith("workspace_owner_"))
+        return "org_spend";
+    if (reason.startsWith("workspace_member_"))
+        return "user_spend";
+    return reason === "rate_limit_reached" ? "session" : "other";
+}
+function codexResetText(rateLimits) {
+    const windows = [rateLimits?.primary, rateLimits?.secondary]
+        .filter((window) => window && typeof window === "object");
+    const reached = windows.filter((window) => Number(window.used_percent) >= 100);
+    const candidates = reached.length > 0 ? reached : windows;
+    const resetAt = candidates
+        .map((window) => Number(window.resets_at))
+        .filter((value) => Number.isFinite(value) && value > 0)
+        .sort((a, b) => a - b)[0];
+    return resetAt ? new Date(resetAt * 1000).toISOString() : null;
+}
+/**
+ * Codex writes a structured RateLimitSnapshot on token_count events. A normal
+ * turn has `rate_limit_reached_type: null`; a blocked turn names the exact
+ * boundary. Reading that field avoids locale-dependent terminal copy.
+ */
+function parseCodexLimitEventFromTranscript(transcript) {
+    let found = null;
+    for (const line of transcript.split("\n")) {
+        if (!line.includes('"rate_limit_reached_type"') && !line.includes('"spend_control_reached"'))
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry?.type !== "event_msg" || entry?.payload?.type !== "token_count")
+            continue;
+        const rateLimits = entry.payload.rate_limits;
+        if (!rateLimits || typeof rateLimits !== "object")
+            continue;
+        const reachedType = typeof rateLimits.rate_limit_reached_type === "string"
+            ? rateLimits.rate_limit_reached_type
+            : null;
+        const spendControlReached = rateLimits.spend_control_reached === true;
+        if (!reachedType && !spendControlReached)
+            continue;
+        const reason = reachedType ?? "spend_control_reached";
+        const at = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
+        found = {
+            kind: codexLimitKind(reason, spendControlReached),
+            at: Number.isNaN(at) ? Date.now() : at,
+            resetText: codexResetText(rateLimits),
+            reason,
+        };
+    }
+    return found;
+}
 // Tail of the raw transcript to ship with the limit event so the server can
 // summarize "what they were working on" immediately — without waiting for the
 // SessionEnd capture (which can lag hours, or drop entirely on Windows).

package/dist/limitEventReporter.d.ts

@@ -0,0 +1,21 @@
+import { type LimitEvent } from "./limitEvent";
+export type LimitEventSource = "claude-code" | "codex";
+export type LimitEventPayload = LimitEvent & {
+    source: LimitEventSource;
+    sessionId?: string;
+    transcriptTail?: string;
+};
+export declare function postLimitEvent(config: {
+    backendUrl: string;
+    token: string;
+}, payload: LimitEventPayload, timeoutMs?: number): Promise<void>;
+export declare function reportTranscriptLimitEvent(args: {
+    config: {
+        backendUrl: string;
+        token: string;
+    };
+    source: LimitEventSource;
+    sessionId?: string;
+    transcript: string;
+    emitMinimalOnMiss?: boolean;
+}): Promise<boolean>;

package/dist/limitEventReporter.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postLimitEvent = postLimitEvent;
+exports.reportTranscriptLimitEvent = reportTranscriptLimitEvent;
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
+const version_1 = require("./version");
+const limitEvent_1 = require("./limitEvent");
+function postLimitEvent(config, payload, timeoutMs = 5_000) {
+    return new Promise((resolve, reject) => {
+        const target = new URL("/api/cli/limitEvent", config.backendUrl);
+        const data = JSON.stringify(payload);
+        const transport = target.protocol === "https:" ? https : http;
+        const request = transport.request({
+            hostname: target.hostname,
+            port: target.port || (target.protocol === "https:" ? 443 : 80),
+            path: target.pathname + target.search,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(data),
+                Authorization: `Bearer ${config.token}`,
+                "X-Codiedev-Cli-Version": version_1.CLI_VERSION,
+            },
+        }, (response) => {
+            let responseBody = "";
+            response.on("data", (chunk) => { responseBody += chunk; });
+            response.on("end", () => {
+                if (response.statusCode && response.statusCode >= 200 && response.statusCode < 300) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`HTTP ${response.statusCode}: ${responseBody}`));
+                }
+            });
+        });
+        request.on("error", reject);
+        request.setTimeout(timeoutMs, () => request.destroy(new Error(`timeout after ${timeoutMs}ms`)));
+        request.write(data);
+        request.end();
+    });
+}
+async function reportTranscriptLimitEvent(args) {
+    const parse = args.source === "codex"
+        ? limitEvent_1.parseCodexLimitEventFromTranscript
+        : limitEvent_1.parseLimitEventFromTranscript;
+    const parsed = parse(args.transcript);
+    if (!parsed && !args.emitMinimalOnMiss)
+        return false;
+    const event = parsed ?? { kind: "other", at: Date.now(), resetText: null };
+    await postLimitEvent(args.config, {
+        source: args.source,
+        ...event,
+        sessionId: args.sessionId,
+        transcriptTail: args.transcript ? (0, limitEvent_1.tailForLimitEvent)(args.transcript) : undefined,
+    });
+    return true;
+}

package/dist/mcp.js

@@ -260,68 +260,6 @@ const TOOLS = [
             required: ["artifactId"],
         },
     },
-    {
-        name: "codiedev_post_to_feed",
-        description: "Publish an artifact to the team's break-room feed with an intent " +
-            "and optional @mentions. Use when the user asks to 'post this to " +
-            "the team', 'publish to the feed', 'share with the team', 'ask the " +
-            "team', or when they want broader visibility than a single ping. " +
-            "Pass the artifact's filename (e.g., 'spec-214.md') and pick an " +
-            "intent that matches the request: share = here's a skill/spec; " +
-            "request_review = please review; request_expertise = I'm stuck, " +
-            "who knows this; link_share = fyi; rfc = proposing a change. " +
-            "Optionally @mention teammates (by first name) so they get a " +
-            "notification. Returns the feed post id.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                filename: {
-                    type: "string",
-                    description: "Artifact filename to attach (e.g., 'spec-214.md'). The post " +
-                        "will render a preview card linking to it.",
-                },
-                title: {
-                    type: "string",
-                    description: "Headline of the post. Short, imperative — e.g., 'Check my " +
-                        "OAuth middleware spec' or 'Anyone know how we handle X?'.",
-                },
-                body: {
-                    type: "string",
-                    description: "Body of the post in markdown. A short explanation of why the " +
-                        "user is posting (the artifact carries the detail).",
-                },
-                intent: {
-                    type: "string",
-                    enum: [
-                        "share",
-                        "request_review",
-                        "request_expertise",
-                        "link_share",
-                        "rfc",
-                    ],
-                    description: "Why the user is posting. See tool description.",
-                },
-                mentions: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Teammate first names (or handles) to @mention. Each mention " +
-                        "creates a notification for that teammate.",
-                },
-                format: {
-                    type: "string",
-                    enum: ["article", "quick", "workflow", "review"],
-                    description: "Post format. Default 'article' if omitted. Use 'quick' for " +
-                        "short one-liners.",
-                },
-                tags: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Optional tags, lowercase, hyphen-safe.",
-                },
-            },
-            required: ["title", "body"],
-        },
-    },
     {
         name: "codiedev_share_with",
         description: "Grant a teammate persistent read (or edit) access to an artifact " +
@@ -374,7 +312,7 @@ const TOOLS = [
             "to that post with X', 'mark as used', or 'upvote'. The 🛠 " +
             "reaction is the signal for 'I used this' and bumps the linked " +
             "artifact's reuse count. Pass the post id (get it from " +
-            "codiedev_get_library or a previous post-to-feed response).",
+            "codiedev_get_library or a previous feed response).",
         inputSchema: {
             type: "object",
             properties: {
@@ -602,8 +540,6 @@ async function dispatchTool(name, args, config) {
             return await handleNote(args, config);
         case "codiedev_promote":
             return await handlePromote(args, config);
-        case "codiedev_post_to_feed":
-            return await handlePostToFeed(args, config);
         case "codiedev_share_with":
             return await handleShareWith(args, config);
         case "codiedev_send_to":
@@ -784,34 +720,6 @@ async function handlePromote(args, config) {
         ],
     };
 }
-async function handlePostToFeed(args, config) {
-    const filename = asStringOrUndefined(args.filename);
-    const title = asString(args.title);
-    const body = asString(args.body);
-    const intent = asStringOrUndefined(args.intent);
-    const format = asStringOrUndefined(args.format);
-    const mentionsRaw = Array.isArray(args.mentions) ? args.mentions : [];
-    const mentions = mentionsRaw.filter((m) => typeof m === "string");
-    const tagsRaw = Array.isArray(args.tags) ? args.tags : [];
-    const tags = tagsRaw.filter((t) => typeof t === "string");
-    if (!title)
-        throw new Error("title required");
-    if (!body)
-        throw new Error("body required");
-    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/post-to-feed", {
-        config,
-        body: { filename, title, body, intent, format, mentions, tags },
-    });
-    const pieces = [`✓ Posted to feed (id=${res.postId}).`];
-    if (res.linkedArtifact?.key)
-        pieces.push(`  attached: ${res.linkedArtifact.key}`);
-    if (res.intent)
-        pieces.push(`  intent: ${res.intent}`);
-    if (res.mentions?.length) {
-        pieces.push(`  mentioned: ${res.mentions.map((m) => m.name).join(", ")}`);
-    }
-    return { content: [{ type: "text", text: pieces.join("\n") }] };
-}
 async function handleShareWith(args, config) {
     const filename = asString(args.filename);
     const to = asString(args.to);

package/dist/repoResolver.js

@@ -23,7 +23,7 @@ function parseRemoteUrl(url) {
     // Harness checkout loses its repoId even though transcript capture can
     // resolve the same raw remote correctly. Check this after URL forms so the
     // colon in `https://` is never mistaken for an SCP separator.
-    const scp = s.match(/^(?:[^@\s]+@)?([^:/\s]+):(.+)$/);
+    const scp = s.match(/^(?:[^@\s]+@)?([^:/\s]+):([^/]+\/.+)$/);
     if (scp) {
         return { host: scp[1].toLowerCase(), ownerName: scp[2].toLowerCase() };
     }

package/dist/security.d.ts

@@ -1,5 +1,6 @@
 export type SecurityHookPhase = "pre" | "post" | "failure";
-export type AgentSurface = "claude-code" | "codex" | "codie-harness";
+export type AgentSurface = "claude-code" | "codex" | "cursor" | "codie-harness";
+export declare const SECURITY_RUNTIME_VERSION = 1;
 export interface RawSecurityHookInput {
     session_id?: string;
     sessionId?: string;
@@ -36,6 +37,8 @@ export interface SecurityWorkflowEvent {
     endpointId?: string;
     endpointName?: string;
     cliVersion?: string;
+    securityRuntimeVersion?: number;
+    securityPolicyVersion?: number;
 }
 export type LocalSecurityAction = "allow" | "alert" | "block";
 export type SecurityCategory = "secret_in_prompt" | "secret_exfiltration" | "destructive_outside_workspace" | "sensitive_file_read" | "sensitive_file_write" | "protected_agent_config_write" | "unapproved_network_egress" | "untrusted_mcp_tool" | "unapproved_command" | "obfuscated_shell_command" | "package_install" | "sensitive_read_then_egress";
@@ -70,6 +73,8 @@ export declare function withEndpointIdentity(event: SecurityWorkflowEvent, ident
     endpointId?: string;
     endpointName?: string;
     cliVersion?: string;
+    securityRuntimeVersion?: number;
+    securityPolicyVersion?: number;
 }): SecurityWorkflowEvent;
 /**
  * Runs before a user prompt reaches the model. This is intentionally narrow:

package/dist/security.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECURITY_RUNTIME_VERSION = void 0;
 exports.withEndpointIdentity = withEndpointIdentity;
 exports.evaluatePromptSecurity = evaluatePromptSecurity;
 exports.evaluateToolSecurity = evaluateToolSecurity;
@@ -41,12 +42,26 @@ exports.buildSecurityWorkflowEvent = buildSecurityWorkflowEvent;
 exports.buildSecurityPromptEvent = buildSecurityPromptEvent;
 exports.buildBlockedSecurityPromptEvent = buildBlockedSecurityPromptEvent;
 const crypto = __importStar(require("crypto"));
+// Advances only when endpoint enforcement behavior changes. This is
+// intentionally independent from the package version so security coverage can
+// remain current across unrelated CLI releases.
+exports.SECURITY_RUNTIME_VERSION = 1;
 function withEndpointIdentity(event, identity) {
     return {
         ...event,
         ...(identity.endpointId ? { endpointId: identity.endpointId.slice(0, 240) } : {}),
         ...(identity.endpointName ? { endpointName: identity.endpointName.slice(0, 240) } : {}),
         ...(identity.cliVersion ? { cliVersion: identity.cliVersion.slice(0, 80) } : {}),
+        ...(typeof identity.securityRuntimeVersion === "number"
+            && Number.isInteger(identity.securityRuntimeVersion)
+            && identity.securityRuntimeVersion > 0
+            ? { securityRuntimeVersion: identity.securityRuntimeVersion }
+            : {}),
+        ...(typeof identity.securityPolicyVersion === "number"
+            && Number.isInteger(identity.securityPolicyVersion)
+            && identity.securityPolicyVersion > 0
+            ? { securityPolicyVersion: identity.securityPolicyVersion }
+            : {}),
     };
 }
 function scopeMatches(value, candidate) {

package/dist/securityInstall.d.ts

@@ -1,4 +1,4 @@
-export type SecuritySurface = "claude-code" | "codex" | "codie-harness";
+export type SecuritySurface = "claude-code" | "codex" | "cursor" | "codie-harness";
 export interface SecurityInstallTarget {
     surface: SecuritySurface;
     configPath: string;
@@ -58,5 +58,6 @@ export declare function inspectSecurityInstallation(paths?: {
     claudeSettingsPath?: string;
     codexHooksPath?: string;
     codexConfigPath?: string;
+    cursorHooksPath?: string;
     codiePluginPath?: string;
 }): SecurityInstallInspection[];

package/dist/securityInstall.js

@@ -153,12 +153,16 @@ function restoreSecurityInstallSnapshot(manifest) {
     }
     return { restored, snapshotId: manifest.rollbackSnapshotId };
 }
-function hookCommands(parsed, eventName) {
+function hookCommands(parsed, eventName, allowFlat) {
     const entries = parsed?.hooks?.[eventName];
     if (!Array.isArray(entries))
         return [];
     const commands = [];
     for (const entry of entries) {
+        const flatCommand = entry.command;
+        if (allowFlat && typeof flatCommand === "string" && (0, detection_1.isCodiedevHookCommand)(flatCommand)) {
+            commands.push(flatCommand);
+        }
         const nested = entry?.hooks;
         if (!Array.isArray(nested))
             continue;
@@ -176,17 +180,23 @@ function inspectJsonSurface(surface, filePath, codexConfigPath) {
     }
     try {
         const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
-        const suffix = surface === "codex" ? "-codex" : "";
-        const expected = [
-            ["UserPromptSubmit", `discover${suffix}`],
-            ["PreToolUse", `security-pre${suffix}`],
-            ["PostToolUse", `security-post${suffix}`],
-            ...(surface === "claude-code"
-                ? [["PostToolUseFailure", `security-failure${suffix}`]]
-                : []),
-        ];
+        const expected = surface === "cursor"
+            ? [
+                ["beforeSubmitPrompt", "security-prompt-cursor"],
+                ["preToolUse", "security-pre-cursor"],
+                ["postToolUse", "security-post-cursor"],
+                ["postToolUseFailure", "security-failure-cursor"],
+            ]
+            : [
+                ["UserPromptSubmit", surface === "codex" ? "discover-codex" : "discover"],
+                ["PreToolUse", surface === "codex" ? "security-pre-codex" : "security-pre"],
+                ["PostToolUse", surface === "codex" ? "security-post-codex" : "security-post"],
+                ...(surface === "claude-code"
+                    ? [["PostToolUseFailure", "security-failure"]]
+                    : []),
+            ];
         const missing = expected
-            .filter(([eventName, subcommand]) => !hookCommands(parsed, eventName).some((command) => command.trim().endsWith(subcommand)))
+            .filter(([eventName, subcommand]) => !hookCommands(parsed, eventName, surface === "cursor").some((command) => command.trim().endsWith(subcommand)))
             .map(([eventName]) => eventName);
         if (missing.length > 0) {
             return { surface, status: "fail", detail: `missing security hooks: ${missing.join(", ")}` };
@@ -207,10 +217,12 @@ function inspectSecurityInstallation(paths = {}) {
     const home = os.homedir();
     const claude = paths.claudeSettingsPath ?? path.join(home, ".claude", "settings.json");
     const codex = paths.codexHooksPath ?? path.join(home, ".codex", "hooks.json");
+    const cursor = paths.cursorHooksPath ?? path.join(home, ".cursor", "hooks.json");
     const codie = paths.codiePluginPath ?? path.join(home, ".config", "opencode", "plugins", "codiedev.js");
     const results = [
         inspectJsonSurface("claude-code", claude),
         inspectJsonSurface("codex", codex, paths.codexConfigPath),
+        inspectJsonSurface("cursor", cursor),
     ];
     if (!fs.existsSync(codie)) {
         results.push({ surface: "codie-harness", status: "not-installed", detail: `${codie} not found` });

package/dist/securityPilot.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSyntheticSecurityPilot = runSyntheticSecurityPilot;
 const security_1 = require("./security");
-const SURFACES = ["claude-code", "codex", "codie-harness"];
+const SURFACES = ["claude-code", "codex", "cursor", "codie-harness"];
 function toolInput(surface, cwd, commandOrPath) {
     const { toolName, ...toolInputValue } = commandOrPath;
     const resolvedToolName = toolName ?? (commandOrPath.file_path ? "Read" : "Bash");

package/dist/securityPolicy.d.ts

@@ -1,4 +1,4 @@
-import type { AgentSurface, EndpointSecurityPolicy } from "./security";
+import { type AgentSurface, type EndpointSecurityPolicy } from "./security";
 export type TrustedPolicyKeys = Record<string, string>;
 /**
  * Vendor policy roots are compiled into the endpoint binary. This prevents a
@@ -29,4 +29,5 @@ export declare function syncEndpointSecurityPolicy(config: {
     backendUrl: string;
     token: string;
     companyId: string;
+    deviceId?: string;
 }, source?: AgentSurface, timeoutMs?: number, stateDir?: string, trustedKeys?: TrustedPolicyKeys): Promise<EndpointSecurityPolicy>;

package/dist/securityPolicy.js

@@ -46,6 +46,8 @@ const http = __importStar(require("http"));
 const https = __importStar(require("https"));
 const path = __importStar(require("path"));
 const configDir_1 = require("./configDir");
+const security_1 = require("./security");
+const version_1 = require("./version");
 const POLICY_FILE = "security-policy.json";
 function policyFile(companyId) {
     if (!companyId)
@@ -150,6 +152,13 @@ async function syncEndpointSecurityPolicy(config, source, timeoutMs = 3_000, sta
     const url = new URL("/api/cli/securityPolicy", config.backendUrl);
     if (source)
         url.searchParams.set("source", source);
+    const cachedPolicy = readEndpointSecurityPolicy(stateDir, trustedKeys, config.companyId);
+    url.searchParams.set("securityRuntimeVersion", String(security_1.SECURITY_RUNTIME_VERSION));
+    url.searchParams.set("cliVersion", version_1.CLI_VERSION);
+    if (cachedPolicy?.policyVersion)
+        url.searchParams.set("securityPolicyVersion", String(cachedPolicy.policyVersion));
+    if (config.deviceId)
+        url.searchParams.set("endpointId", config.deviceId);
     const transport = url.protocol === "https:" ? https : http;
     const policy = await new Promise((resolve, reject) => {
         const request = transport.request(url, {

package/dist/utils.d.ts

@@ -104,7 +104,7 @@ export declare function installOpenCodeCapturePlugin(agentSecurityEnabled?: bool
  * the presence of any `github.copilot*` directory as the Copilot fingerprint.
  */
 export declare function vscodeCopilotInstalled(): boolean;
-export declare function upsertCodiedevHook(hooks: Record<string, unknown>, eventName: string, subcommand: string, matcher?: string): void;
+export declare function upsertCodiedevHook(hooks: Record<string, unknown>, eventName: string, subcommand: string, matcher?: string | null): void;
 /** Remove Codiedev's entries for one event while preserving foreign hooks. */
 export declare function removeCodiedevHook(hooks: Record<string, unknown>, eventName: string): boolean;
 export declare function installHook(agentSecurityEnabled?: boolean): void;
@@ -170,7 +170,12 @@ export declare function cleanupCodexMcp(): void;
  */
 export declare function installCodexMcp(): boolean;
 export declare function installCodexHook(agentSecurityEnabled?: boolean): void;
-export declare function installCursorHook(): void;
+export declare function ensureCodexLimitHookInstalled(): void;
+export declare function installCursorHook(agentSecurityEnabled?: boolean): void;
+/** Repair Cursor's complete flat hook set after upgrades or configuration
+ * drift. This is deliberately separate from Claude Code's nested-hook healer:
+ * the schemas and event names differ, and mixing them risks corrupting both. */
+export declare function ensureCursorCodiedevHooksInstalled(agentSecurityEnabled?: boolean): void;
 export interface ParsedStats {
     messageCount: number;
     toolCallCount: number;
@@ -258,6 +263,8 @@ export declare const CAPTURE_THROTTLE_MS: number;
 export declare const SWEEP_MIN_AGE_MS: number;
 export declare function resolveCaptureFinal(argv2: string | undefined): boolean | undefined;
 export declare function finishInputTmpFile(sessionId: string | undefined): string;
+export declare function captureUploadTmpFile(sessionId: string | undefined, mode: "immediate" | "deferred", pid?: number, now?: number): string;
+export declare function cancelDeferredCaptureUpload(sessionId: string, deps?: Pick<typeof fs, "unlinkSync">): boolean;
 export declare function decideDispatch(args: {
     final: boolean;
     lastUploadAt: number | null;
@@ -332,3 +339,4 @@ interface DeferredUploadDeps extends UploadDeps {
 }
 export declare function runDeferredUpload(jobFile: string, delayMs: number, deps: DeferredUploadDeps): Promise<void>;
 export declare function transcriptReadSkipReason(err: unknown): string;
+export declare function shouldReportCaptureSkip(final: boolean | undefined): boolean;