codiedev 0.3.5 → 0.4.0

package/dist/cli.js

@@ -23,6 +23,7 @@ const inbox_1 = require("./commands/inbox");
 const note_1 = require("./commands/note");
 const promote_1 = require("./commands/promote");
 const reverseTicket_1 = require("./commands/reverseTicket");
+const doctor_1 = require("./commands/doctor");
 const HELP = `
 CodieDev CLI
 
@@ -32,6 +33,7 @@ CodieDev CLI
 
 Connect:
   codiedev connect                       Link Claude Code / Codex to your org
+  codiedev doctor                        Verify your setup after connecting
 
 Artifacts:
   codiedev push <file.md>                Author or update an artifact
@@ -314,6 +316,10 @@ async function main() {
             case "connect":
                 await (0, connect_1.runConnect)();
                 return;
+            case "doctor":
+            case "verify":
+                await (0, doctor_1.runDoctor)(rest);
+                return;
             case "push":
                 await (0, push_1.runPush)(rest);
                 return;

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -0,0 +1,263 @@
+"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.runDoctor = runDoctor;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const shared_1 = require("./shared");
+const utils_1 = require("../utils");
+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");
+const CODEX_INSTRUCTIONS_PATH = path.join(os.homedir(), ".codex", "AGENTS.md");
+function symbol(status) {
+    if (status === "pass")
+        return "✓";
+    if (status === "warn")
+        return "!";
+    return "✗";
+}
+function claudeCodeInstalled() {
+    return fs.existsSync(path.join(os.homedir(), ".claude"));
+}
+function codexInstalled() {
+    return fs.existsSync(path.join(os.homedir(), ".codex"));
+}
+function hasCodiedevHook(settingsPath, hookKey) {
+    try {
+        if (!fs.existsSync(settingsPath))
+            return false;
+        const raw = fs.readFileSync(settingsPath, "utf8");
+        const parsed = JSON.parse(raw);
+        const hooks = parsed.hooks?.[hookKey];
+        if (!Array.isArray(hooks))
+            return false;
+        return hooks.some((h) => {
+            const inner = h.hooks;
+            if (!Array.isArray(inner))
+                return false;
+            return inner.some((x) => (x.command ?? "").includes("codiedev-hook"));
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function hasCodiedevInstructions(instructionsPath) {
+    try {
+        if (!fs.existsSync(instructionsPath))
+            return false;
+        const raw = fs.readFileSync(instructionsPath, "utf8");
+        return raw.includes("codiedev-cli:begin");
+    }
+    catch {
+        return false;
+    }
+}
+function hasGhCli() {
+    try {
+        (0, child_process_1.execSync)("gh --version", { stdio: ["pipe", "pipe", "pipe"] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runDoctor(_args) {
+    const checks = [];
+    console.log("\nCodieDev doctor — checking your setup…\n");
+    // 1. Config file
+    const config = (0, utils_1.readConfig)();
+    if (!config) {
+        checks.push({
+            name: "CodieDev config (~/.codiedev/config.json)",
+            status: "fail",
+            detail: "Not found. Run `codiedev connect` first.",
+        });
+        report(checks);
+        process.exit(1);
+    }
+    checks.push({
+        name: "CodieDev config",
+        status: "pass",
+        detail: `connected to ${config.companyName}`,
+    });
+    // 2. Token still valid + backend reachable (re-validate)
+    try {
+        const res = await fetch(`${config.backendUrl}/api/cli/validateToken`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ token: config.token }),
+        });
+        if (res.ok) {
+            checks.push({
+                name: "Backend reachable + token valid",
+                status: "pass",
+            });
+        }
+        else {
+            checks.push({
+                name: "Backend reachable + token valid",
+                status: "fail",
+                detail: `HTTP ${res.status} — run \`codiedev connect\` with a fresh token`,
+            });
+        }
+    }
+    catch (err) {
+        checks.push({
+            name: "Backend reachable + token valid",
+            status: "fail",
+            detail: err.message,
+        });
+    }
+    // 3. Authenticated endpoint smoke test (inbox query)
+    try {
+        await (0, shared_1.apiRequest)("GET", "/api/cli/inbox", {
+            config,
+            query: { limit: 1 },
+        });
+        checks.push({
+            name: "Authenticated endpoint smoke test (`codiedev inbox`)",
+            status: "pass",
+        });
+    }
+    catch (err) {
+        checks.push({
+            name: "Authenticated endpoint smoke test",
+            status: "fail",
+            detail: err.message,
+        });
+    }
+    // 4. Tracked repos
+    const repoCount = config.repos?.length ?? 0;
+    checks.push({
+        name: "Tracked repos",
+        status: repoCount > 0 ? "pass" : "warn",
+        detail: repoCount > 0
+            ? `${repoCount} repo${repoCount === 1 ? "" : "s"}`
+            : "0 — link repos in the portal so sessions get captured",
+    });
+    // 5. Claude Code setup (if present)
+    if (claudeCodeInstalled()) {
+        checks.push({
+            name: "Claude Code detected",
+            status: "pass",
+            detail: "~/.claude",
+        });
+        checks.push({
+            name: "Claude Code SessionEnd hook",
+            status: hasCodiedevHook(CLAUDE_SETTINGS_PATH, "SessionEnd") ? "pass" : "fail",
+            detail: hasCodiedevHook(CLAUDE_SETTINGS_PATH, "SessionEnd")
+                ? "~/.claude/settings.json"
+                : "missing — re-run `codiedev connect`",
+        });
+        checks.push({
+            name: "Claude Code agent instructions",
+            status: hasCodiedevInstructions(CLAUDE_INSTRUCTIONS_PATH) ? "pass" : "fail",
+            detail: hasCodiedevInstructions(CLAUDE_INSTRUCTIONS_PATH)
+                ? "~/.claude/CLAUDE.md"
+                : "missing — re-run `codiedev connect`",
+        });
+    }
+    else {
+        checks.push({
+            name: "Claude Code",
+            status: "warn",
+            detail: "not installed on this machine",
+        });
+    }
+    // 6. Codex setup (if present)
+    if (codexInstalled()) {
+        checks.push({
+            name: "Codex detected",
+            status: "pass",
+            detail: "~/.codex",
+        });
+        checks.push({
+            name: "Codex Stop hook",
+            status: hasCodiedevHook(CODEX_HOOKS_PATH, "Stop") ? "pass" : "fail",
+            detail: hasCodiedevHook(CODEX_HOOKS_PATH, "Stop")
+                ? "~/.codex/hooks.json"
+                : "missing — re-run `codiedev connect`",
+        });
+        checks.push({
+            name: "Codex agent instructions",
+            status: hasCodiedevInstructions(CODEX_INSTRUCTIONS_PATH) ? "pass" : "fail",
+            detail: hasCodiedevInstructions(CODEX_INSTRUCTIONS_PATH)
+                ? "~/.codex/AGENTS.md"
+                : "missing — re-run `codiedev connect`",
+        });
+    }
+    else {
+        checks.push({
+            name: "Codex",
+            status: "warn",
+            detail: "not installed on this machine",
+        });
+    }
+    // 7. gh CLI (optional — only needed for reverse-ticket)
+    checks.push({
+        name: "GitHub CLI (`gh`) for reverse-ticket command",
+        status: hasGhCli() ? "pass" : "warn",
+        detail: hasGhCli()
+            ? "installed"
+            : "not installed — only needed if you use `codiedev reverse-ticket <pr-url>`",
+    });
+    report(checks);
+    const failures = checks.filter((c) => c.status === "fail");
+    if (failures.length > 0) {
+        process.exit(1);
+    }
+}
+function report(checks) {
+    for (const c of checks) {
+        const sym = symbol(c.status);
+        const line = c.detail ? `  ${sym} ${c.name} — ${c.detail}` : `  ${sym} ${c.name}`;
+        console.log(line);
+    }
+    const fails = checks.filter((c) => c.status === "fail").length;
+    const warns = checks.filter((c) => c.status === "warn").length;
+    const passes = checks.filter((c) => c.status === "pass").length;
+    console.log();
+    if (fails === 0) {
+        console.log(`All core checks passed (${passes} ok${warns > 0 ? `, ${warns} warning${warns === 1 ? "" : "s"}` : ""}). You're set.`);
+    }
+    else {
+        console.log(`${fails} check${fails === 1 ? "" : "s"} failed. Re-run \`codiedev connect\` or check your token at https://codiedev.com/portal/integrations/claude-code`);
+    }
+    console.log();
+}

package/dist/connect.js

@@ -185,9 +185,9 @@ async function runConnect() {
         for (const target of installed) {
             console.log(`  - ${target}`);
         }
-        console.log("Sessions will be captured automatically.\n");
-    }
-    else {
-        console.log();
+        console.log("Sessions will be captured automatically.");
     }
+    console.log();
+    console.log("Run `codiedev doctor` to verify everything's wired up.");
+    console.log();
 }

package/dist/mcp.js

@@ -52,7 +52,7 @@ const path = __importStar(require("path"));
 const utils_1 = require("./utils");
 const shared_1 = require("./commands/shared");
 const PKG_NAME = "codiedev";
-const PKG_VERSION = "0.3.0";
+const PKG_VERSION = "0.4.0";
 // ─────────────────────────────────────────────────────────────────────────────
 // Tool definitions — descriptions tuned so Claude/Codex resolve natural-language
 // requests into the right tool without manual steering.
@@ -202,6 +202,176 @@ 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 " +
+            "without sending a notification. Use when the user says 'share this " +
+            "with Greg' or 'give Jason access', and doesn't want to surface it " +
+            "as a message. If they want the teammate actively notified, use " +
+            "codiedev_send_to instead.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filename: { type: "string", description: "Artifact filename, e.g. 'spec-214.md'." },
+                to: {
+                    type: "string",
+                    description: "Teammate first name, full name, or email. Ambiguous matches " +
+                        "return a list — reprompt the user if so.",
+                },
+                role: {
+                    type: "string",
+                    enum: ["read", "edit"],
+                    description: "Access level. Default 'read' if omitted.",
+                },
+            },
+            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 Greg', 'ask " +
+            "Greg to look at this', or 'share this with Jason and tell him 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_react",
+        description: "React to a feed post with an emoji. Use when the user says 'react " +
+            "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).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: { type: "string", description: "Feed post id." },
+                emoji: {
+                    type: "string",
+                    enum: ["👍", "🔥", "💡", "🛠", "👑"],
+                    description: "Reaction emoji. 🛠 = 'I used this' (counts heaviest toward " +
+                        "the author's score and the artifact's reuse count).",
+                },
+            },
+            required: ["postId", "emoji"],
+        },
+    },
+    {
+        name: "codiedev_search",
+        description: "Search the team's artifact library by natural-language query. Use " +
+            "when the user asks 'has anyone solved X?', 'find me the spec on Y', " +
+            "or 'look for prior work on Z'. Always search before pushing a new " +
+            "artifact so the user doesn't duplicate work. Returns ranked hits " +
+            "with title, type, filename key, and a snippet.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Natural-language search query." },
+                limit: { type: "integer", description: "Max hits. Default 10." },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "codiedev_get_library",
+        description: "List artifacts in the team library, scoped to what the current " +
+            "user authored, what's been shared with them, or everything in the " +
+            "company. Use when the user asks 'show me my artifacts', 'what did " +
+            "I push?', 'what has Greg shared with me?', or 'browse the library'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                scope: {
+                    type: "string",
+                    enum: ["mine", "shared", "all"],
+                    description: "'mine' = artifacts I authored (default). 'shared' = artifacts " +
+                        "explicitly shared with me. 'all' = everything in the company.",
+                },
+                type: {
+                    type: "string",
+                    enum: ["spec", "bugfix", "decision", "proposal", "review", "note"],
+                    description: "Filter to one artifact type.",
+                },
+                folderPath: { type: "string", description: "Filter to one folder path." },
+                limit: { type: "integer", description: "Max rows. Default 50." },
+            },
+        },
+    },
 ];
 // ─────────────────────────────────────────────────────────────────────────────
 // Server
@@ -241,6 +411,18 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 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":
+                return await handleSendTo(args, config);
+            case "codiedev_react":
+                return await handleReact(args, config);
+            case "codiedev_search":
+                return await handleSearch(args, config);
+            case "codiedev_get_library":
+                return await handleGetLibrary(args, config);
             default:
                 return {
                     isError: true,
@@ -394,6 +576,193 @@ 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);
+    const role = asStringOrUndefined(args.role);
+    if (!filename)
+        throw new Error("filename required");
+    if (!to)
+        throw new Error("to required");
+    try {
+        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/share-with", {
+            config,
+            body: { filename, to, role },
+        });
+        const verb = res.action === "added"
+            ? "Shared"
+            : res.action === "updated"
+                ? "Updated share for"
+                : "Already shared with";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✓ ${verb} ${res.recipient.name} <${res.recipient.email}> on ${filename} (role=${role ?? "read"}).`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return formatAmbiguousRecipient(err, to);
+    }
+}
+async function handleSendTo(args, config) {
+    const filename = asString(args.filename);
+    const to = asString(args.to);
+    const message = asStringOrUndefined(args.message);
+    if (!filename)
+        throw new Error("filename required");
+    if (!to)
+        throw new Error("to required");
+    try {
+        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/send-to", {
+            config,
+            body: { filename, to, message },
+        });
+        const suffix = res.pingId ? ` with a message.` : ` (no message).`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✓ Sent ${filename} to ${res.recipient.name} <${res.recipient.email}>${suffix}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return formatAmbiguousRecipient(err, to);
+    }
+}
+async function handleReact(args, config) {
+    const postId = asString(args.postId);
+    const emoji = asString(args.emoji);
+    if (!postId)
+        throw new Error("postId required");
+    if (!emoji)
+        throw new Error("emoji required");
+    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/react", {
+        config,
+        body: { postId, emoji },
+    });
+    const verb = res.action === "added"
+        ? "Reacted"
+        : res.action === "removed"
+            ? "Removed reaction"
+            : "Swapped reaction to";
+    return {
+        content: [{ type: "text", text: `✓ ${verb} ${res.emoji}` }],
+    };
+}
+async function handleSearch(args, config) {
+    const query = asString(args.query);
+    const limit = asIntOrUndefined(args.limit);
+    if (!query)
+        throw new Error("query required");
+    const res = await (0, shared_1.apiRequest)("GET", "/api/cli/search", {
+        config,
+        query: { q: query, limit: limit?.toString() },
+    });
+    if (res.hits.length === 0) {
+        return {
+            content: [{ type: "text", text: `No artifacts matched "${query}".` }],
+        };
+    }
+    const lines = [`Found ${res.hits.length} match${res.hits.length === 1 ? "" : "es"}:`, ""];
+    for (const h of res.hits) {
+        lines.push(`[${h.type}] ${h.title}${h.key ? ` (${h.key})` : ""}`);
+        if (h.snippet) {
+            lines.push(`    ${h.snippet.slice(0, 160)}${h.snippet.length > 160 ? "…" : ""}`);
+        }
+        lines.push("");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleGetLibrary(args, config) {
+    const scope = asStringOrUndefined(args.scope);
+    const type = asStringOrUndefined(args.type);
+    const folderPath = asStringOrUndefined(args.folderPath);
+    const limit = asIntOrUndefined(args.limit);
+    const res = await (0, shared_1.apiRequest)("GET", "/api/cli/library", {
+        config,
+        query: {
+            scope,
+            type,
+            folderPath,
+            limit: limit?.toString(),
+        },
+    });
+    if (res.artifacts.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Library is empty${scope && scope !== "mine" ? ` for scope=${scope}` : ""}.`,
+                },
+            ],
+        };
+    }
+    const lines = [
+        `Library · scope=${scope ?? "mine"} · ${res.artifacts.length} item${res.artifacts.length === 1 ? "" : "s"}`,
+        "",
+    ];
+    for (const a of res.artifacts) {
+        const loc = a.folderPath ? `${a.folderPath}/` : "";
+        const v = a.version ? ` v${a.version}` : "";
+        const life = a.lifecycle ? ` · ${a.lifecycle}` : "";
+        const when = a.updatedAt ? ` · ${(0, shared_1.timeAgo)(a.updatedAt)}` : "";
+        lines.push(`[${a.type}] ${loc}${a.key ?? a.title}${v}${life}${when}`);
+        lines.push(`    ${a.title}`);
+        lines.push("");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function formatAmbiguousRecipient(err, to) {
+    const e = err;
+    if (e.status === 409 && e.body?.candidates?.length) {
+        const list = e.body.candidates
+            .map((c) => `- ${c.name} <${c.email}>`)
+            .join("\n");
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Multiple recipients matched "${to}". Ask the user which:\n${list}`,
+                },
+            ],
+        };
+    }
+    throw err;
+}
 // ─────────────────────────────────────────────────────────────────────────────
 // Helpers
 // ─────────────────────────────────────────────────────────────────────────────

package/dist/utils.js

@@ -206,13 +206,19 @@ thought, use the \`codiedev\` CLI via Bash:**
 
 | Intent | Command |
 |---|---|
-| "push this spec" / "share this with the team" | \`codiedev push <file.md>\` |
+| "push this spec" / "save this as a skill" | \`codiedev push <file.md>\` |
 | "pull X" / "grab the latest spec-X" / "what did Maya push?" | \`codiedev pull <key>\` |
 | "ping Nic about this" / "ask Maya for her take" | \`codiedev ping <name> "<msg>" [--with <key>]\` |
 | "any messages?" / "check my inbox" / "what did Nic say?" | \`codiedev inbox\` |
 | "read Nic's reply" / "mark that ping read" | \`codiedev read <ping-id>\` |
 | "note that X is a follow-up" / "remember X" | \`codiedev note "<text>"\` |
 | "promote the extracted spec" | \`codiedev promote <artifact-id>\` |
+| "post this to the team" / "publish to the feed" / "share with the team" | MCP tool \`codiedev_post_to_feed\` |
+| "share with Greg" / "give Jason access" (no notification) | MCP tool \`codiedev_share_with\` |
+| "send this to Greg" / "ask Greg to look at this" | MCP tool \`codiedev_send_to\` |
+| "find something about X" / "has anyone solved Y?" | MCP tool \`codiedev_search\` |
+| "show my library" / "what artifacts exist?" | MCP tool \`codiedev_get_library\` |
+| "react 🛠 to that post" / "mark as used" | MCP tool \`codiedev_react\` |
 
 **Filename conventions (set artifact type automatically):**
 - \`spec-*.md\` → spec
@@ -231,6 +237,22 @@ thought, use the \`codiedev\` CLI via Bash:**
 **Teammate names:** first name usually works (\`codiedev ping nic ...\`).
 If ambiguous, the CLI returns candidates — retry with the full email.
 
+**Feed posts (broad team reach):** use \`codiedev_post_to_feed\` when the
+user wants visibility beyond one teammate — e.g., announcing a new skill,
+asking the team who knows about X, proposing a change. Always pass an
+\`intent\` that matches the request: \`share\` (here's a skill),
+\`request_review\`, \`request_expertise\` (stuck, who knows this),
+\`link_share\` (fyi), or \`rfc\` (proposing a change). Attach a \`filename\`
+to link a specific artifact and \`mentions\` to tag teammates.
+
+**Search before pushing.** For any "save this as …" request, call
+\`codiedev_search\` first with a relevant query. If prior art exists, pull
+it and iterate rather than duplicating.
+
+**Sharing vs sending:** \`codiedev_share_with\` is silent (access only, no
+notification). \`codiedev_send_to\` both grants access AND pings the
+recipient. Use send when the user is actively looping someone in.
+
 **Errors:**
 - "not connected" → user needs to run \`npx codiedev connect\` with their
   API token from https://codiedev.com/portal/integrations/claude-code

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "Connect Claude Code or Codex to CodieDev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "./dist/cli.js",