continuous-improvement 3.1.0 → 3.9.1

package/lib/gateguard-state.mjs

@@ -0,0 +1,85 @@
+/**
+ * Gateguard per-session state.
+ *
+ * State file: <sessionDir>/gateguard-session.json. sessionDir resolves to
+ * GATEGUARD_SESSION_DIR (env override, used by tests) or
+ * ~/.claude/instincts/<projectHash>/ in production.
+ *
+ * V1 limitations (documented for honesty, not mitigated in code):
+ * - Honor system: clearance is granted whenever the agent sets
+ *   `_gateguard_facts_presented: true` in tool_input or has a prior per-file
+ *   marker. The hook cannot verify that real investigation occurred.
+ * - State-file deletion: rm'ing the state file resets every gate in the
+ *   session. Defensible because the session itself is the trust boundary;
+ *   the cap below limits cumulative damage.
+ * - Concurrency: two parallel hook invocations can race the read+write.
+ *   Acceptable trade-off vs OS-specific atomic-rename complexity on Windows.
+ * - Cap: MAX_CLEARED_FILES caps the number of distinct files a single
+ *   session can clear, bounding stuck-loop / rogue-agent damage.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const MAX_CLEARED_FILES = 50;
+export function resolveSessionDir() {
+    const fromEnv = process.env.GATEGUARD_SESSION_DIR;
+    if (fromEnv)
+        return fromEnv;
+    const home = process.env.HOME || process.env.USERPROFILE || homedir();
+    const projectRoot = resolveProjectRoot();
+    const projectHash = createHash("sha256").update(projectRoot).digest("hex").slice(0, 12);
+    return join(home, ".claude", "instincts", projectHash);
+}
+function resolveProjectRoot() {
+    const fromEnv = process.env.CLAUDE_PROJECT_DIR;
+    if (fromEnv)
+        return fromEnv;
+    try {
+        const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (root)
+            return root;
+    }
+    catch {
+        // not in a git repo
+    }
+    return "global";
+}
+export function loadState(sessionDir) {
+    const path = join(sessionDir, "gateguard-session.json");
+    if (!existsSync(path)) {
+        return { created_at: new Date().toISOString(), cleared_files: {} };
+    }
+    try {
+        const raw = readFileSync(path, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            created_at: parsed.created_at ?? new Date().toISOString(),
+            cleared_files: parsed.cleared_files ?? {},
+        };
+    }
+    catch {
+        return { created_at: new Date().toISOString(), cleared_files: {} };
+    }
+}
+export function saveState(sessionDir, state) {
+    if (!existsSync(sessionDir))
+        mkdirSync(sessionDir, { recursive: true });
+    writeFileSync(join(sessionDir, "gateguard-session.json"), `${JSON.stringify(state, null, 2)}\n`);
+}
+export function isCapReached(state) {
+    return Object.keys(state.cleared_files).length >= MAX_CLEARED_FILES;
+}
+export function markFileCleared(state, filePath) {
+    return {
+        ...state,
+        cleared_files: {
+            ...state.cleared_files,
+            [filePath]: { cleared_at: new Date().toISOString() },
+        },
+    };
+}

package/lib/observe-event.mjs

@@ -0,0 +1,128 @@
+// observe-event.mts — Pure parsers for the Mulahazah observation hook.
+//
+// These functions have NO I/O. They turn raw stdin text and tool input/output
+// payloads into shaped data the entrypoint (src/bin/observe.mts) writes to
+// observations.jsonl. Pure separation lets the unit tests cover schema edge
+// cases (malformed JSON, missing fields, oversized payloads) without ever
+// touching the filesystem or computing project hashes.
+//
+// Truncation budgets match the prior bash/jq behavior to preserve the existing
+// privacy contract: input head ≤500 chars, output head ≤200 chars.
+const INPUT_TRUNCATE = 500;
+const OUTPUT_TRUNCATE = 200;
+/**
+ * Parse the raw JSON stdin payload from a Claude Code PreToolUse/PostToolUse
+ * hook event. Returns null for any unparseable or schema-invalid input —
+ * never throws. Empty/null/array payloads are rejected (the harness only
+ * sends objects).
+ *
+ * Field-name normalisation: Claude Code's PostToolUse payload uses
+ * `tool_response`. Older mocks and some third-party harnesses emit
+ * `tool_output` or `toolOutput`. We accept all three at the boundary and
+ * expose a single `tool_response` field downstream so the discriminator and
+ * `summariseOutput` only have to know one name.
+ */
+export function parseHookPayload(raw) {
+    if (!raw)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const obj = parsed;
+    if (typeof obj.tool_name !== "string" || obj.tool_name.length === 0) {
+        return null;
+    }
+    const toolResponse = obj.tool_response !== undefined
+        ? obj.tool_response
+        : obj.tool_output !== undefined
+            ? obj.tool_output
+            : obj.toolOutput;
+    return {
+        tool_name: obj.tool_name,
+        session_id: typeof obj.session_id === "string" ? obj.session_id : "",
+        tool_input: obj.tool_input,
+        tool_response: toolResponse,
+    };
+}
+/**
+ * Extract a tool-aware short summary from `tool_input`. Tool-specific cases
+ * cover the high-frequency surfaces the linter/analyser reads (Bash command
+ * head, Edit/Write/Read file_path, Grep/Glob pattern). Unknown tools fall
+ * back to JSON.stringify(input) capped at INPUT_TRUNCATE.
+ *
+ * Returns an empty string when the expected field is missing on a known tool
+ * or when input is null/undefined — never returns "undefined" or "null"
+ * literals to the caller.
+ */
+export function summariseInput(toolName, input) {
+    if (input === null || input === undefined)
+        return "";
+    switch (toolName) {
+        case "Bash": {
+            const cmd = readStringField(input, "command");
+            return cmd === null ? "" : truncate(cmd, INPUT_TRUNCATE);
+        }
+        case "Edit":
+        case "Write":
+        case "Read":
+        case "NotebookEdit": {
+            const path = readStringField(input, "file_path");
+            return path === null ? "" : truncate(path, INPUT_TRUNCATE);
+        }
+        case "Grep":
+        case "Glob": {
+            const pattern = readStringField(input, "pattern");
+            return pattern === null ? "" : truncate(pattern, INPUT_TRUNCATE);
+        }
+        default: {
+            // Unknown tool: stringify input so we record *something* useful for
+            // future analysis. Truncate to keep observations.jsonl row size bounded.
+            let serialised;
+            try {
+                serialised = JSON.stringify(input);
+            }
+            catch {
+                serialised = "";
+            }
+            return truncate(serialised ?? "", INPUT_TRUNCATE);
+        }
+    }
+}
+/**
+ * Extract a short summary from `tool_response`. Strings pass through (capped
+ * at OUTPUT_TRUNCATE); numbers/booleans coerce to string; objects
+ * JSON-stringify. Null/undefined collapse to "".
+ */
+export function summariseOutput(output) {
+    if (output === null || output === undefined)
+        return "";
+    if (typeof output === "string")
+        return truncate(output, OUTPUT_TRUNCATE);
+    if (typeof output === "number" || typeof output === "boolean") {
+        return String(output);
+    }
+    let serialised;
+    try {
+        serialised = JSON.stringify(output);
+    }
+    catch {
+        serialised = "";
+    }
+    return truncate(serialised ?? "", OUTPUT_TRUNCATE);
+}
+function readStringField(input, field) {
+    if (input === null || typeof input !== "object")
+        return null;
+    const value = input[field];
+    return typeof value === "string" ? value : null;
+}
+function truncate(value, max) {
+    return value.length > max ? value.slice(0, max) : value;
+}

package/lib/plugin-metadata.mjs

@@ -0,0 +1,435 @@
+export const PACKAGE_NAME = "continuous-improvement";
+export const VERSION = "3.9.0";
+export const PLUGIN_MODES = ["beginner", "expert"];
+const REPOSITORY_URL = "https://github.com/naimkatiman/continuous-improvement";
+const HOMEPAGE_URL = `${REPOSITORY_URL}#readme`;
+const AUTHOR = {
+    name: "naimkatiman",
+    url: "https://github.com/naimkatiman",
+};
+const KEYWORDS = [
+    "claude-code",
+    "claude-code-skill",
+    "ai-agent",
+    "agent-skill",
+    "ai-discipline",
+    "mulahazah",
+    "instinct",
+    "hooks",
+    "mcp",
+    "mcp-server",
+    "github-action",
+    "transcript-linter",
+];
+const CLAUDE_PLUGIN_CATEGORY = "productivity";
+const SHARED_PLUGIN_DESCRIPTION = "Stops Claude Code from skipping research, claiming 'done' without verifying, and repeating yesterday's mistakes. The 7 Laws of AI Agent Discipline — 13 enforcement skills, gating hooks, and the Mulahazah auto-leveling instinct engine.";
+// Four vendored upstream companions registered alongside the CI plugin.
+// Each entry points at a pinned-SHA snapshot under third-party/<name>/.
+// See third-party/MANIFEST.md for refresh recipes and per-snapshot
+// OUR_NOTES.md for integration scope and overlap matrices. The unified
+// /superpowers dispatcher (skills/superpowers.md) routes across all four.
+// Product-management coverage is supplied by phuryn/pm-skills as an
+// out-of-band marketplace install — see docs/THIRD_PARTY.md for the
+// `claude plugin marketplace add phuryn/pm-skills` recipe and the eight
+// installable plugins (pm-toolkit, pm-product-strategy, pm-product-discovery,
+// pm-market-research, pm-data-analytics, pm-marketing-growth,
+// pm-go-to-market, pm-execution).
+const THIRD_PARTY_COMPANIONS = [
+    {
+        name: "superpowers",
+        description: "Obra's core skills library: TDD, debugging, brainstorming, writing-plans, executing-plans, dispatching-parallel-agents, using-git-worktrees, finishing-a-development-branch, subagent-driven-development, requesting-code-review, receiving-code-review, systematic-debugging, verification-before-completion, writing-skills, using-superpowers. Vendored snapshot at third-party/superpowers/ pinned to upstream SHA f2cbfbe (v5.1.0). Companion to the /superpowers dispatcher in continuous-improvement plugin.",
+        version: "5.1.0",
+        source: "./third-party/superpowers",
+        author: {
+            name: "Jesse Vincent",
+            email: "jesse@fsck.com",
+        },
+        category: "workflow",
+        homepage: "https://github.com/obra/superpowers",
+    },
+    {
+        name: "agent-skills",
+        description: "Addy Osmani's production-grade engineering skills for AI coding agents — 21 skills covering the full software development lifecycle: spec-driven-development, source-driven-development, context-engineering, idea-refine, incremental-implementation, test-driven-development, code-review-and-quality, code-simplification, security-and-hardening, debugging-and-error-recovery, performance-optimization, api-and-interface-design, frontend-ui-engineering, browser-testing-with-devtools, ci-cd-and-automation, deprecation-and-migration, documentation-and-adrs, git-workflow-and-versioning, planning-and-task-breakdown, shipping-and-launch, using-agent-skills. Vendored snapshot at third-party/addy-agent-skills/ pinned to upstream SHA 742dca5 (v1.0.0).",
+        version: "1.0.0",
+        source: "./third-party/addy-agent-skills",
+        author: {
+            name: "Addy Osmani",
+        },
+        category: "workflow",
+        homepage: "https://github.com/addyosmani/agent-skills",
+    },
+    {
+        name: "ruflo-swarm",
+        description: "Agent teams, swarm coordination, Monitor streams, and worktree isolation. Wraps 4 swarm_* + 8 agent_* MCP tools (12 total) plus 6 topologies (hierarchical, mesh, hierarchical-mesh, ring, star, adaptive). Slash commands /swarm and /watch. Skills swarm-init and monitor-stream. Cherry-picked from ruvnet/ruflo monorepo (the other 31 plugins are explicitly out of scope). Vendored snapshot at third-party/ruflo-swarm/ pinned to upstream SHA addb5cd (v0.2.0). Activation note: assets reference unpinned npx @claude-flow/cli@latest — supply-chain risk inert until installed.",
+        version: "0.2.0",
+        source: "./third-party/ruflo-swarm",
+        author: {
+            name: "ruvnet",
+            url: "https://github.com/ruvnet",
+        },
+        category: "orchestration",
+        homepage: "https://github.com/ruvnet/ruflo",
+    },
+    {
+        name: "oh-my-claudecode",
+        description: "Multi-agent orchestration system for Claude Code — 39 skills + 19 agents covering audit, plan, build, verify, ship, release, retrospective, and ops. Includes ralph (autonomous PRD loop), release, ultrawork, ultraqa, team, trace, visual-verdict, debug, deep-dive, deep-interview, autopilot, autoresearch. Vendored snapshot at third-party/oh-my-claudecode/ pinned to upstream SHA aacde3e (v4.13.6). Heavy overlap with continuous-improvement /ralph and /superpowers — pick per task.",
+        version: "4.13.6",
+        source: "./third-party/oh-my-claudecode",
+        author: {
+            name: "Yeachan-Heo",
+        },
+        category: "orchestration",
+        homepage: "https://github.com/Yeachan-Heo/oh-my-claudecode",
+    },
+];
+export function isPluginMode(value) {
+    return value === "beginner" || value === "expert";
+}
+const BEGINNER_TOOL_ENTRIES = [
+    {
+        name: "ci_status",
+        description: "Show current level, instinct count, and observation count for this project. Good starting point to see what the system has learned.",
+        manifestWhat: "See what the system has learned about your project",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "ci_instincts",
+        description: "List all learned instincts for this project with their confidence levels and behaviors.",
+        manifestWhat: "List all learned behaviors with confidence levels",
+        inputSchema: {
+            type: "object",
+            properties: {
+                min_confidence: {
+                    type: "number",
+                    description: "Minimum confidence to show (default: 0)",
+                    default: 0,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "ci_reflect",
+        description: "Generate a structured reflection for the current session. Provide a summary of what you worked on.",
+        manifestWhat: "Reflect on what you did this session",
+        inputSchema: {
+            type: "object",
+            properties: {
+                summary: {
+                    type: "string",
+                    description: "Brief summary of what was done this session",
+                },
+            },
+            required: ["summary"],
+        },
+    },
+];
+const EXPERT_TOOL_ENTRIES = [
+    {
+        name: "ci_reinforce",
+        description: "Accept or reject an instinct suggestion. Adjusts confidence: +0.15 for accept, -0.1 for reject.",
+        manifestWhat: "Accept or reject instinct suggestions to tune confidence",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instinct_id: { type: "string", description: "The instinct ID to reinforce" },
+                accepted: {
+                    type: "boolean",
+                    description: "true = accept (+0.15), false = reject (-0.1)",
+                },
+            },
+            required: ["instinct_id", "accepted"],
+        },
+    },
+    {
+        name: "ci_create_instinct",
+        description: "Manually create a new instinct with a trigger, body, and starting confidence.",
+        manifestWhat: "Manually create instincts with custom triggers and confidence",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Unique instinct ID (kebab-case)" },
+                trigger: { type: "string", description: "When this instinct applies" },
+                body: { type: "string", description: "The behavior to follow" },
+                confidence: {
+                    type: "number",
+                    description: "Starting confidence 0.0-0.9 (default: 0.6)",
+                    default: 0.6,
+                },
+                domain: {
+                    type: "string",
+                    description: "Domain: workflow|tooling|testing|patterns|code-style",
+                    default: "workflow",
+                },
+                scope: {
+                    type: "string",
+                    description: "Scope: project|global",
+                    default: "project",
+                },
+            },
+            required: ["id", "trigger", "body"],
+        },
+    },
+    {
+        name: "ci_observations",
+        description: "View recent tool call observations captured by hooks.",
+        manifestWhat: "View raw tool call observations captured by hooks",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Number of recent observations to return (default: 20)",
+                    default: 20,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "ci_export",
+        description: "Export all instincts as a JSON array for sharing or backup.",
+        manifestWhat: "Export instincts as JSON for sharing or backup",
+        inputSchema: {
+            type: "object",
+            properties: {
+                scope: {
+                    type: "string",
+                    description: "Which instincts: project|global|all (default: all)",
+                    default: "all",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "ci_import",
+        description: "Import instincts from a JSON array. Skips duplicates by ID.",
+        manifestWhat: "Import instincts from JSON (skip duplicates)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instincts_json: {
+                    type: "string",
+                    description: "JSON array of instinct objects to import",
+                },
+                scope: {
+                    type: "string",
+                    description: "Import to: project|global (default: project)",
+                    default: "project",
+                },
+            },
+            required: ["instincts_json"],
+        },
+    },
+    {
+        name: "ci_plan_init",
+        description: "Create task_plan.md, findings.md, and progress.md in the project root for persistent file-based planning.",
+        manifestWhat: "Create project-root planning files for persistent task memory",
+        inputSchema: {
+            type: "object",
+            properties: {
+                goal: { type: "string", description: "Goal for the planning workflow" },
+                phases: {
+                    type: "array",
+                    description: "Optional ordered phase names. Defaults to Research, Plan, Execute, Verify, Reflect.",
+                    items: { type: "string" },
+                },
+                force: {
+                    type: "boolean",
+                    description: "Overwrite existing planning files",
+                    default: false,
+                },
+            },
+            required: ["goal"],
+        },
+    },
+    {
+        name: "ci_plan_status",
+        description: "Summarize the status of task_plan.md, findings.md, and progress.md in the project root.",
+        manifestWhat: "Summarize task_plan.md, findings.md, and progress.md status",
+        inputSchema: {
+            type: "object",
+            properties: {
+                include_contents: {
+                    type: "boolean",
+                    description: "Include raw file contents in the response",
+                    default: false,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "ci_dashboard",
+        description: "Visual dashboard showing instinct health, observation stats, confidence distribution, and learning progress.",
+        manifestWhat: "Visual dashboard showing instinct health, confidence distribution, and learning progress",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "ci_load_pack",
+        description: "Load a starter instinct pack (react, python, go) into the current project.",
+        manifestWhat: "Load starter instinct packs (react, python, go) into the current project",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pack: { type: "string", description: "Pack name: react, python, or go" },
+            },
+            required: ["pack"],
+        },
+    },
+];
+const MODE_METADATA = {
+    beginner: {
+        description: "Beginner mode: see what your agent learned, list its instincts, and request a session reflection. Bundles four discipline skills (gateguard, para-memory-files, tdd-workflow, verification-loop) so research, memory, tests, and verification happen by default.",
+        hooks: ["PreToolUse", "PostToolUse"],
+        hookDescription: "Silently captures every tool call as observations. Lightweight and non-blocking.",
+    },
+    expert: {
+        description: "Expert mode: tune confidence, manage instincts, and persist plans on disk. Adds safety, token-budget, and strategic-compact skills plus the /learn-eval command so long sessions stay disciplined and learnings survive context resets.",
+        hooks: ["PreToolUse", "PostToolUse", "SessionStart", "SessionEnd"],
+        hookDescription: "Full hook suite: observation capture + session-level instinct loading and auto-reflection.",
+    },
+};
+function getToolCatalog(mode) {
+    return mode === "expert"
+        ? [...BEGINNER_TOOL_ENTRIES, ...EXPERT_TOOL_ENTRIES]
+        : [...BEGINNER_TOOL_ENTRIES];
+}
+export function getToolDefinitions(mode) {
+    return getToolCatalog(mode).map(({ name, description, inputSchema }) => ({
+        name,
+        description,
+        inputSchema,
+    }));
+}
+export function getToolNames(mode) {
+    return getToolCatalog(mode).map((tool) => tool.name);
+}
+export function getPluginManifest(mode) {
+    const modeMetadata = MODE_METADATA[mode];
+    const mcpServerConfig = {
+        command: "node",
+        args: ["<install-path>/bin/mcp-server.mjs", "--mode", mode],
+    };
+    return {
+        name: PACKAGE_NAME,
+        version: VERSION,
+        mode,
+        description: modeMetadata.description,
+        tools: getToolCatalog(mode).map((tool) => ({
+            name: tool.name,
+            what: tool.manifestWhat,
+        })),
+        setup: {
+            claude_desktop: {
+                mcpServers: {
+                    [PACKAGE_NAME]: mcpServerConfig,
+                },
+            },
+            claude_code: {
+                mcpServers: {
+                    [PACKAGE_NAME]: mcpServerConfig,
+                },
+            },
+        },
+        hooks: {
+            included: [...modeMetadata.hooks],
+            description: modeMetadata.hookDescription,
+        },
+    };
+}
+export function getClaudePluginManifest() {
+    return {
+        name: PACKAGE_NAME,
+        version: VERSION,
+        description: SHARED_PLUGIN_DESCRIPTION,
+        author: AUTHOR,
+        homepage: HOMEPAGE_URL,
+        repository: REPOSITORY_URL,
+        license: "MIT",
+        keywords: [...KEYWORDS],
+    };
+}
+export function getPluginHooksConfig() {
+    const gateguardCommand = {
+        type: "command",
+        command: "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gateguard.mjs\"",
+        timeout: 5,
+    };
+    const observeCommand = {
+        type: "command",
+        command: "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/observe.sh\"",
+        timeout: 5,
+    };
+    const sessionCommand = {
+        type: "command",
+        command: "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/session.sh\"",
+        timeout: 5,
+    };
+    const threeSectionCloseCommand = {
+        type: "command",
+        command: "node \"${CLAUDE_PLUGIN_ROOT}/hooks/three-section-close.mjs\"",
+        timeout: 5,
+    };
+    return {
+        description: "Gateguard fact-forcing PreToolUse, observation, session lifecycle, and 3-section-close discipline hooks for continuous-improvement.",
+        hooks: {
+            // gateguard runs FIRST so its block decision short-circuits before
+            // observe.sh records the tool call. observe.sh stays in PreToolUse for
+            // the observation feed; the Claude Code host runs both regardless of
+            // gateguard's decision.
+            PreToolUse: [{ hooks: [gateguardCommand, observeCommand] }],
+            PostToolUse: [{ hooks: [observeCommand] }],
+            SessionStart: [{ hooks: [sessionCommand] }],
+            SessionEnd: [{ hooks: [sessionCommand] }],
+            Stop: [{ hooks: [threeSectionCloseCommand] }],
+        },
+    };
+}
+export function getClaudePluginMarketplaceManifest() {
+    return {
+        name: `${PACKAGE_NAME}-dev`,
+        description: "Development marketplace for the Continuous Improvement Claude Code plugin.",
+        owner: {
+            name: AUTHOR.name,
+        },
+        plugins: [
+            {
+                name: PACKAGE_NAME,
+                description: SHARED_PLUGIN_DESCRIPTION,
+                version: VERSION,
+                source: "./",
+                author: {
+                    name: AUTHOR.name,
+                },
+                category: CLAUDE_PLUGIN_CATEGORY,
+                homepage: REPOSITORY_URL,
+            },
+        ],
+    };
+}
+export function getClaudeRepoMarketplaceManifest(extraPlugins = []) {
+    return {
+        name: PACKAGE_NAME,
+        description: "Marketplace for the Continuous Improvement Claude Code plugin and four vendored upstream companions (Obra superpowers, addyosmani/agent-skills, ruflo-swarm, oh-my-claudecode). All four companions are pinned-SHA snapshots in third-party/ — see third-party/MANIFEST.md for refresh recipes and per-snapshot OUR_NOTES.md for integration scope. Product-management coverage is provided out-of-band by phuryn/pm-skills via Claude Code's plugin marketplace — see docs/THIRD_PARTY.md.",
+        owner: {
+            name: AUTHOR.name,
+        },
+        plugins: [
+            {
+                name: PACKAGE_NAME,
+                description: SHARED_PLUGIN_DESCRIPTION,
+                version: VERSION,
+                source: `./plugins/${PACKAGE_NAME}`,
+                author: {
+                    name: AUTHOR.name,
+                },
+                category: CLAUDE_PLUGIN_CATEGORY,
+                homepage: REPOSITORY_URL,
+            },
+            ...THIRD_PARTY_COMPANIONS,
+            ...extraPlugins,
+        ],
+    };
+}