codiedev 0.9.52 → 0.10.0-beta.1

package/dist/hook.js

@@ -37,7 +37,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDiscoveryContext = buildDiscoveryContext;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
-const path = __importStar(require("path"));
 const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
@@ -45,7 +44,13 @@ const utils_1 = require("./utils");
 const limitEventReporter_1 = require("./limitEventReporter");
 const version_1 = require("./version");
 const captureLog_1 = require("./captureLog");
+const security_1 = require("./security");
+const securitySession_1 = require("./securitySession");
+const securityPolicy_1 = require("./securityPolicy");
+const securityFeature_1 = require("./securityFeature");
+const securityInventory_1 = require("./securityInventory");
 const captureExclusions_1 = require("./captureExclusions");
+const cursorHooks_1 = require("./cursorHooks");
 // 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
@@ -118,6 +123,8 @@ async function readAndPostLimitEvent(hookInput, source, emitMinimalOnMiss) {
     const tp = hookInput.transcript_path;
     if (tp) {
         try {
+            // Codex invokes Stop after every turn. Bound this read so long-running
+            // sessions do not repeatedly load their entire rollout into memory.
             transcript = readTranscriptTailFile(tp);
         }
         catch {
@@ -231,7 +238,7 @@ timeoutMs) {
 // postJson variant that returns the parsed response body — the upload-URL
 // handshake needs the { uploadUrl } the server hands back. No timeout: runs
 // only in detached uploader children, never on the shutdown clock.
-function postJsonForResponse(url, body, bearerToken) {
+function postJsonForResponse(url, body, bearerToken, timeoutMs) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
         const data = JSON.stringify(body);
@@ -265,10 +272,145 @@ function postJsonForResponse(url, body, bearerToken) {
             });
         });
         req.on("error", reject);
+        if (timeoutMs) {
+            req.setTimeout(timeoutMs, () => {
+                req.destroy(new Error(`timeout after ${timeoutMs}ms`));
+            });
+        }
         req.write(data);
         req.end();
     });
 }
+// Local policy runs synchronously before a tool executes. Workflow telemetry
+// is dispatched separately and fail-open, so a detector outage or timeout can
+// never delay or override the deterministic endpoint decision.
+async function runSecurityHook(hookInput, phase, source, uploadTelemetry = true) {
+    const config = (0, utils_1.readConfig)();
+    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
+        return;
+    const policy = (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId);
+    const sessionId = hookInput.session_id ?? hookInput.sessionId;
+    const sessionSignal = phase === "pre" ? (0, securitySession_1.readSessionSecuritySignal)(sessionId) : undefined;
+    const localDecision = (0, security_1.evaluateToolSecurity)(hookInput, phase, policy, source, sessionSignal);
+    if (phase === "post" && (0, security_1.securityInputHasSensitivePath)(hookInput)) {
+        (0, securitySession_1.recordSensitiveReadSignal)(sessionId);
+    }
+    const event = (0, security_1.buildSecurityWorkflowEvent)(hookInput, phase, source);
+    if (event) {
+        event.localDecision = localDecision.action;
+        event.localCategory = localDecision.category;
+    }
+    if (localDecision.action === "block" && phase === "pre") {
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "security",
+            sessionId: hookInput.session_id ?? hookInput.sessionId ?? "unknown",
+            outcome: "ok",
+            detail: `phase=${phase} localDecision=block category=${localDecision.category}`,
+        });
+        if (uploadTelemetry)
+            dispatchSecurityEventUpload(event);
+        const response = source === "cursor"
+            ? (0, cursorHooks_1.cursorPreToolBlockResponse)(localDecision.reason ?? "Codie blocked this action")
+            : {
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: localDecision.reason,
+                },
+            };
+        process.stdout.write(JSON.stringify(response));
+        return;
+    }
+    if (!event)
+        return;
+    if (uploadTelemetry)
+        dispatchSecurityEventUpload(event);
+}
+function runPromptSecurityHook(hookInput, source, uploadTelemetry = true) {
+    const config = (0, utils_1.readConfig)();
+    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
+        return false;
+    const decision = (0, security_1.evaluatePromptSecurity)(hookInput.prompt, (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId), source);
+    if (decision.action !== "block")
+        return false;
+    (0, captureLog_1.appendCaptureLog)({
+        stage: "security",
+        sessionId: hookInput.session_id ?? hookInput.sessionId ?? "unknown",
+        outcome: "ok",
+        detail: `phase=prompt localDecision=block category=${decision.category} telemetry=${uploadTelemetry ? "enabled" : "suppressed"} cwd=${hookInput.cwd ?? "unknown"}`,
+    });
+    if (uploadTelemetry) {
+        dispatchSecurityEventUpload((0, security_1.buildBlockedSecurityPromptEvent)(hookInput, source, decision.category ?? "secret_in_prompt"));
+    }
+    const response = source === "cursor"
+        ? (0, cursorHooks_1.cursorPromptBlockResponse)(decision.reason ?? "Codie blocked this prompt")
+        : { decision: "block", reason: decision.reason };
+    process.stdout.write(JSON.stringify(response));
+    return true;
+}
+function dispatchAllowedPromptSecurityEvent(hookInput, source) {
+    const config = (0, utils_1.readConfig)();
+    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
+        return;
+    const event = (0, security_1.buildSecurityPromptEvent)(hookInput, source, Date.now, (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId));
+    if (event)
+        dispatchSecurityEventUpload(event);
+}
+function dispatchSecurityEventUpload(event) {
+    if (!event || !(0, securityFeature_1.isAgentSecurityEnabled)((0, utils_1.readConfig)()))
+        return;
+    try {
+        const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1], "security-upload"], {
+            detached: true,
+            stdio: ["pipe", "ignore", "ignore"],
+        });
+        child.stdin?.end(JSON.stringify(event));
+        child.unref();
+    }
+    catch {
+        // Telemetry is best-effort and must never delay local enforcement.
+    }
+}
+async function runSecurityEventUpload() {
+    const config = (0, utils_1.readConfig)();
+    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
+        return;
+    const startedAt = Date.now();
+    try {
+        const raw = await readStdin();
+        const event = JSON.parse(raw);
+        const cachedPolicy = (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId);
+        const eventWithEndpoint = (0, security_1.withEndpointIdentity)(event, {
+            endpointId: config.deviceId,
+            endpointName: config.deviceName,
+            cliVersion: version_1.CLI_VERSION,
+            securityRuntimeVersion: security_1.SECURITY_RUNTIME_VERSION,
+            securityPolicyVersion: cachedPolicy?.policyVersion,
+        });
+        const result = await postJsonForResponse(`${config.backendUrl}/api/cli/securityEvent`, { ...eventWithEndpoint }, config.token, 
+        // Leave room for a cold backend and durable scheduling. This uploader is
+        // detached, so the network budget never delays the developer's prompt or
+        // tool call. Policy refreshes use the separately signed sync endpoint.
+        5_000);
+        if (result?.policy?.schemaVersion === 1) {
+            (0, securityPolicy_1.writeEndpointSecurityPolicy)(result.policy, undefined, undefined, config.companyId);
+        }
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "security",
+            sessionId: event.sessionId,
+            outcome: "ok",
+            detail: `phase=${event.phase} elapsedMs=${Date.now() - startedAt} verdict=${String(result?.verdict ?? "unknown")}`,
+        });
+    }
+    catch (err) {
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "security",
+            sessionId: "upload",
+            outcome: "ERROR",
+            detail: `elapsedMs=${Date.now() - startedAt} ${err.message}`,
+        });
+    }
+}
 // Raw-bytes POST to a Convex storage upload URL (no auth header — the URL
 // itself is the one-time credential). Returns the parsed { storageId }.
 function postBytes(url, bytes, contentType) {
@@ -324,7 +466,7 @@ async function readStdin() {
 function resolveMode(arg) {
     if (arg === "capture-codex")
         return "codex";
-    if (arg === "capture-cursor")
+    if (arg === "capture-cursor" || arg === "backup-cursor")
         return "cursor";
     if (arg === "capture-opencode" || arg === "capture-opencode-final")
         return "opencode";
@@ -392,6 +534,20 @@ async function main() {
         }
         process.exit(0);
     }
+    // Daily component drift scan runs in a detached hook process. The parent
+    // SessionStart path only performs a timestamp read, so agent startup never
+    // waits for filesystem traversal or an inventory upload.
+    if (process.argv[2] === "security-inventory-upload") {
+        const config = (0, utils_1.readConfig)();
+        if (config && (0, securityFeature_1.isAgentSecurityEnabled)(config)) {
+            const inventory = (0, securityInventory_1.buildSecurityInventory)({ workspace: process.argv[3] || process.cwd() });
+            try {
+                await (0, securityInventory_1.uploadSecurityInventory)(inventory, config);
+            }
+            catch { /* retry after the daily inventory window */ }
+        }
+        process.exit(0);
+    }
     // Detached backup uploader child (spawned by runBackup below). The job file
     // carries only { root, files }; the child re-reads config from disk. No stdin
     // needed, so handle it before readStdin() like the capture uploader above.
@@ -428,28 +584,73 @@ async function main() {
         }
         process.exit(0);
     }
+    // Detached, best-effort security telemetry. Local policy decisions have
+    // already completed in the parent hook; this child can never delay or alter
+    // the developer's action.
+    if (process.argv[2] === "security-upload") {
+        await runSecurityEventUpload();
+        process.exit(0);
+    }
     let hookInput = {};
     try {
         const raw = await readStdin();
         if (raw.trim()) {
-            hookInput = JSON.parse(raw);
+            const parsed = JSON.parse(raw);
+            hookInput = (process.argv[2]?.endsWith("-cursor")
+                ? (0, cursorHooks_1.normalizeCursorHookInput)(parsed)
+                : parsed);
         }
     }
     catch {
         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
-    // no Codiedev request at all for this session.
-    if ((0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput)) {
+    // Privacy exclusions suppress every Codiedev upload, but they must never
+    // disable local security enforcement. Security hooks run first with telemetry
+    // disabled; all other hook modes still exit before making a network request.
+    const captureIgnored = (0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput);
+    const securityCommand = process.argv[2] ?? "";
+    const securityMatch = securityCommand.match(/^security-(pre|post|failure)(?:-(codex|cursor|codie))?$/);
+    if (securityMatch) {
+        const source = securityMatch[2] === "codex"
+            ? "codex"
+            : securityMatch[2] === "cursor"
+                ? "cursor"
+                : securityMatch[2] === "codie"
+                    ? "codie-harness"
+                    : "claude-code";
+        await runSecurityHook(hookInput, securityMatch[1], source, !captureIgnored);
         process.exit(0);
     }
     // UserPromptSubmit discovery path — separate from session capture.
-    if (process.argv[2] === "discover") {
+    const promptCommand = process.argv[2] ?? "";
+    if (promptCommand === "security-prompt-cursor") {
+        if (runPromptSecurityHook(hookInput, "cursor", !captureIgnored))
+            return;
+        if (captureIgnored)
+            return;
+        dispatchAllowedPromptSecurityEvent(hookInput, "cursor");
+        process.exit(0);
+    }
+    if (process.argv[2] === "discover" ||
+        process.argv[2] === "discover-codex" ||
+        process.argv[2] === "discover-codie") {
+        const source = promptCommand === "discover-codex"
+            ? "codex"
+            : promptCommand === "discover-codie"
+                ? "codie-harness"
+                : "claude-code";
+        // Security runs first and locally. A blocked prompt is erased before it
+        // reaches the model, so discovery must not send it to the backend.
+        if (runPromptSecurityHook(hookInput, source, !captureIgnored))
+            return;
+        if (captureIgnored)
+            return;
+        dispatchAllowedPromptSecurityEvent(hookInput, source);
         await runDiscover(hookInput.prompt);
         return;
     }
+    if (captureIgnored)
+        process.exit(0);
     // StopFailure (matcher rate_limit): post the rate-limit event.
     if (process.argv[2] === "limit") {
         await runStopFailure(hookInput);
@@ -460,8 +661,24 @@ async function main() {
         return;
     }
     // SessionStart: post the capture-coverage denominator ping. Tiny + fast.
-    if (process.argv[2] === "session-start" || process.argv[2] === "session-start-opencode") {
-        await runSessionStart(hookInput, process.argv[2] === "session-start-opencode" ? "opencode" : "claude-code");
+    if (process.argv[2] === "session-start" ||
+        process.argv[2] === "session-start-cursor" ||
+        process.argv[2] === "session-start-opencode") {
+        if ((0, securityFeature_1.isAgentSecurityEnabled)((0, utils_1.readConfig)()) && (0, securityInventory_1.securityInventoryDue)()) {
+            try {
+                const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1], "security-inventory-upload", hookInput.cwd || process.cwd()], {
+                    detached: true,
+                    stdio: "ignore",
+                });
+                child.unref();
+            }
+            catch { /* daily inventory is best-effort */ }
+        }
+        await runSessionStart(hookInput, process.argv[2] === "session-start-opencode"
+            ? "opencode"
+            : process.argv[2] === "session-start-cursor"
+                ? "cursor"
+                : "claude-code");
         return;
     }
     // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets
@@ -469,7 +686,12 @@ async function main() {
     // no self-heal and could stay stripped forever while SessionStart kept
     // pinging (the Sonifi "starts arrive, captures never" loss) — re-wired on
     // their next Stop/SessionEnd. One read + one write, only when missing.
-    (0, utils_1.ensureAllCodiedevHooksInstalled)();
+    if ((process.argv[2] ?? "").endsWith("-cursor")) {
+        (0, utils_1.ensureCursorCodiedevHooksInstalled)();
+    }
+    else {
+        (0, utils_1.ensureAllCodiedevHooksInstalled)();
+    }
     if (process.argv[2] === "capture-codex")
         (0, utils_1.ensureCodexLimitHookInstalled)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
@@ -484,13 +706,11 @@ async function main() {
     // extension) where SessionEnd may never come — the silent zero-capture bug.
     // Same detached capture-finish child as SessionEnd, marked non-final so the
     // server renews the session lease instead of summarizing immediately.
-    if (process.argv[2] === "backup") {
+    if (process.argv[2] === "backup" || process.argv[2] === "backup-cursor") {
         if (transcript_path) {
             try {
                 (0, utils_1.dispatchCaptureFinish)({
-                    // "capture" = the claude-code entrypoint literal, same as the
-                    // SessionEnd path below (resolveMode maps it to claude-code).
-                    mode: "capture",
+                    mode: process.argv[2] === "backup-cursor" ? "capture-cursor" : "capture",
                     session_id,
                     transcript_path,
                     cwd,
@@ -550,10 +770,9 @@ async function main() {
             transcript_path,
             cwd,
             workspace_roots,
-            // final:true ONLY for claude-code's SessionEnd. Codex routes its
-            // per-turn Stop hook through "capture-codex" — final:true there would
-            // close the server lease every turn. Codex/Cursor keep legacy
-            // behaviour (final omitted).
+            // final:true for real SessionEnd signals (Claude Code and Cursor).
+            // Codex routes its per-turn Stop hook through "capture-codex" —
+            // final:true there would close the server lease every turn.
             final: (0, utils_1.resolveCaptureFinal)(process.argv[2]),
         }, process.argv[1], { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile: jobFile, openSync: fs.openSync, closeSync: fs.closeSync });
     }
@@ -630,7 +849,9 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             outcome: "skip",
             detail: reason,
         });
-        await postSessionSkip(config, session_id, reason);
+        if ((0, utils_1.shouldReportCaptureSkip)(input.final)) {
+            await postSessionSkip(config, session_id, reason);
+        }
         return;
     }
     // Snapshot the RAW transcript before normalization below flattens it to
@@ -642,6 +863,9 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     if (parserMode === "opencode") {
         transcriptContent = (0, utils_1.normalizeOpenCodeTranscript)(transcriptContent);
     }
+    else if (parserMode === "cursor") {
+        transcriptContent = (0, cursorHooks_1.normalizeCursorTranscript)(transcriptContent);
+    }
     // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
     // need the git remote of the workspace.
     let remoteUrl = null;
@@ -668,9 +892,26 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     const matchedRepo = remoteUrl ? (0, utils_1.matchRepo)(remoteUrl, config.repos) : null;
     const stats = parserMode === "codex"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
-        : parserMode === "cursor"
-            ? { messageCount: 0, toolCallCount: 0 }
-            : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
+        : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
+    // Cursor can emit duplicate lifecycle notifications while one transcript
+    // path is still byte-empty. Never use parsed message count here: Cursor's
+    // private JSONL shape can evolve independently, and parser drift must not
+    // silently discard a real non-empty session.
+    if (parserMode === "cursor" && (0, cursorHooks_1.isCursorTranscriptEmpty)(rawTranscriptContent)) {
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "capture-finish",
+            sessionId: session_id,
+            outcome: "skip",
+            detail: "empty-cursor-transcript",
+        });
+        // A non-final stop snapshot is only a backup; reporting it as a skipped
+        // session would close/remove server-side start coverage while the session
+        // is still alive. The real SessionEnd remains responsible for a skip ping.
+        if ((0, utils_1.shouldReportCaptureSkip)(input.final)) {
+            await postSessionSkip(config, session_id, "empty-cursor-transcript");
+        }
+        return;
+    }
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
     // Session→merge join keys: the branch + HEAD sha the work happened on. Matched
     // server-side against a merged MR/PR's source_branch / commits for AI attribution.
@@ -763,7 +1004,7 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     // which is the "supersede" mechanism for the deferred path.
     try {
         const hookScriptPath = process.argv[1];
-        const tmpFile = path.join(os.tmpdir(), `codiedev-capture-${session_id ?? process.pid}.json`);
+        const tmpFile = (0, utils_1.captureUploadTmpFile)(session_id, decision.mode);
         if (decision.mode === "immediate") {
             (0, utils_1.dispatchCaptureDetached)({
                 url: `${config.backendUrl}/api/captureSession`,
@@ -771,6 +1012,11 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
                 body: payload,
                 scopePaths,
             }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync });
+            // The immediate payload is durable before removing the older scheduled
+            // snapshot. Do this for every immediate dispatch, not only SessionEnd:
+            // first/outside-window snapshots also supersede a sleeping deferred job.
+            if (session_id)
+                (0, utils_1.cancelDeferredCaptureUpload)(session_id);
             // Retry any earlier capture jobs that failed to upload (transient network
             // blips), excluding the one we just dispatched. Best-effort, detached.
             // Skip the sweep on deferred path — the deferred child will handle uploading.

package/dist/limitEvent.d.ts

@@ -7,6 +7,10 @@ export interface LimitEvent {
 }
 export declare function classifyLimitKind(text: string): LimitKind;
 export declare function parseLimitEventFromTranscript(transcript: string): LimitEvent | null;
-/** Parse the structured rate-limit snapshot written to Codex rollout JSONL. */
+/**
+ * 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.
+ */
 export declare function parseCodexLimitEventFromTranscript(transcript: string): LimitEvent | null;
 export declare function tailForLimitEvent(transcript: string, maxChars?: number): string;

package/dist/limitEvent.js

@@ -69,7 +69,11 @@ function codexResetText(rateLimits) {
         .sort((a, b) => a - b)[0];
     return resetAt ? new Date(resetAt * 1000).toISOString() : null;
 }
-/** Parse the structured rate-limit snapshot written to Codex rollout JSONL. */
+/**
+ * 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")) {

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

@@ -13,14 +13,20 @@ function parseRemoteUrl(url) {
     let s = url.trim();
     if (s.endsWith(".git"))
         s = s.slice(0, -4);
-    const ssh = s.match(/^git@([^:]+):(.+)$/);
-    if (ssh) {
-        return { host: ssh[1].toLowerCase(), ownerName: ssh[2].toLowerCase() };
-    }
     const https = s.match(/^https?:\/\/([^/]+)\/(.+)$/);
     if (https) {
         return { host: https[1].toLowerCase(), ownerName: https[2].toLowerCase() };
     }
+    // Codie strips SSH userinfo before putting a remote in the gateway header,
+    // so `git@gitlab.com:owner/repo.git` arrives here as
+    // `gitlab.com:owner/repo.git`. Accept both forms; otherwise every SSH-cloned
+    // 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]+):([^/]+\/.+)$/);
+    if (scp) {
+        return { host: scp[1].toLowerCase(), ownerName: scp[2].toLowerCase() };
+    }
     return null;
 }
 function resolveRepoForCapture(input) {