codecartographer-pi 0.12.11 → 0.14.0

package/dist/core/guide.d.ts

@@ -0,0 +1,18 @@
+/** Packaged agent-skill directory. Wrappers serve its contents through codecarto_guide. */
+export declare const packagedAgentSkillDir: string;
+/** A guide document: the main skill or one of its topic references. */
+export type GuideDocument = {
+    /** `overview` for SKILL.md, otherwise the reference's basename without `.md`. */
+    topic: string;
+    /** Markdown body, with SKILL.md's installer frontmatter stripped. */
+    content: string;
+};
+/** Topic names available to {@link readGuide}, `overview` first. */
+export declare function listGuideTopics(): Promise<string[]>;
+/**
+ * Read one guide document.
+ * @param topic - `overview` (default) for the main skill, or a reference name from {@link listGuideTopics}.
+ * @returns the requested document.
+ * @throws when the packaged skill is missing, or the topic is not one of {@link listGuideTopics}.
+ */
+export declare function readGuide(topic?: string): Promise<GuideDocument>;

package/dist/core/guide.js

@@ -0,0 +1,50 @@
+// Serves the packaged agent skill — the instructions for driving this server —
+// so an MCP client can read them without installing the skill files. The shipped
+// markdown under agent-skill/ is the single source: nothing here duplicates its
+// prose, and a drift test would have nothing to compare.
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { pathExists } from "./utils.js";
+import { packageRoot } from "./workspace.js";
+/** Packaged agent-skill directory. Wrappers serve its contents through codecarto_guide. */
+export const packagedAgentSkillDir = join(packageRoot, "agent-skill", "codecartographer");
+/**
+ * Strip a leading YAML frontmatter block. The frontmatter is skill-installer
+ * metadata (name, version, license) that carries no instruction value for an
+ * agent reading the guide through the tool.
+ */
+function stripFrontmatter(markdown) {
+    const match = /^---\r?\n[\s\S]*?\r?\n---\r?\n/.exec(markdown);
+    return match ? markdown.slice(match[0].length).trimStart() : markdown;
+}
+/** Topic names available to {@link readGuide}, `overview` first. */
+export async function listGuideTopics() {
+    const referencesDir = join(packagedAgentSkillDir, "references");
+    if (!(await pathExists(referencesDir)))
+        return ["overview"];
+    const names = (await readdir(referencesDir))
+        .filter((name) => name.endsWith(".md"))
+        .map((name) => basename(name, ".md"))
+        .sort();
+    return ["overview", ...names];
+}
+/**
+ * Read one guide document.
+ * @param topic - `overview` (default) for the main skill, or a reference name from {@link listGuideTopics}.
+ * @returns the requested document.
+ * @throws when the packaged skill is missing, or the topic is not one of {@link listGuideTopics}.
+ */
+export async function readGuide(topic = "overview") {
+    const requested = topic.trim() || "overview";
+    const available = await listGuideTopics();
+    if (!available.includes(requested)) {
+        throw new Error(`Unknown guide topic ${requested}. Available: ${available.join(", ")}.`);
+    }
+    const path = requested === "overview"
+        ? join(packagedAgentSkillDir, "SKILL.md")
+        : join(packagedAgentSkillDir, "references", `${requested}.md`);
+    if (!(await pathExists(path))) {
+        throw new Error(`Packaged agent skill is missing at ${path}. Reinstall codecartographer-pi.`);
+    }
+    return { topic: requested, content: stripFrontmatter(await readFile(path, "utf8")) };
+}

package/dist/core/index.d.ts

@@ -8,6 +8,7 @@ export * from "./workspace.ts";
 export * from "./completion.ts";
 export * from "./orchestrator-config.ts";
 export * from "./usage.ts";
+export * from "./guide.ts";
 export * from "./dashboard.ts";
 export * from "./library.ts";
 export * from "./synthesis.ts";

package/dist/core/index.js

@@ -11,6 +11,7 @@ export * from "./workspace.js";
 export * from "./completion.js";
 export * from "./orchestrator-config.js";
 export * from "./usage.js";
+export * from "./guide.js";
 export * from "./dashboard.js";
 export * from "./library.js";
 export * from "./synthesis.js";

package/dist/core/prompts.js

@@ -4,6 +4,7 @@
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { pathExists } from "./utils.js";
+import { describeScaffoldStaleness } from "./workspace.js";
 import { runPhasePreflight } from "./synthesis.js";
 export function describeEntry(entry) {
     const parts = [];
@@ -30,6 +31,7 @@ export function collectRoutedCarryForward(state, targetPhaseId) {
 export async function buildPhasePrompt(state, phase, forced, options = {}) {
     const preflight = options.preflight ?? await runPhasePreflight(state, phase);
     const synthesisWorkflow = state.pipeline.workflow_name === "evidence-backed-project-synthesis";
+    const handoffTemplateExists = await pathExists(join(state.workspaceDir, "templates", "phase-handoff.yaml"));
     const lines = [
         `Read .codecarto/GUIDE.md and continue the CodeCartographer workflow for the phase \`${phase.id}\`.`,
         synthesisWorkflow
@@ -39,8 +41,10 @@ export async function buildPhasePrompt(state, phase, forced, options = {}) {
         "Required reads before analysis:",
         "- .codecarto/GUIDE.md",
         "- .codecarto/workflow/status.yaml",
-        "- .codecarto/templates/phase-handoff.yaml",
     ];
+    if (handoffTemplateExists) {
+        lines.push("- .codecarto/templates/phase-handoff.yaml");
+    }
     const primaryOutput = phase.primary_output ? `.codecarto/${phase.primary_output}` : undefined;
     if (primaryOutput) {
         lines.push(`- ${primaryOutput} if it already exists (continue instead of duplicating work)`);
@@ -69,6 +73,21 @@ export async function buildPhasePrompt(state, phase, forced, options = {}) {
     if (await pathExists(decisionsPath)) {
         lines.push("- .codecarto/DECISIONS.md (numbered project decisions; new entries are appended in your closeout)");
     }
+    // Stale-scaffold warnings (issue #85): a workspace copied from an old
+    // template can contradict the runtime contract. Both surfaces render this
+    // prompt, so warn here rather than per-host.
+    const scaffoldWarnings = [];
+    if (!handoffTemplateExists) {
+        scaffoldWarnings.push(`.codecarto/templates/phase-handoff.yaml is missing — this scaffold predates the v0.12.0 handoff contract. Completion still requires a phase handoff at .codecarto/scratch/handoffs/${phase.id}.yaml; refresh the framework-owned files (GUIDE.md, templates/, workflow/VALIDATE.md, workflow/pipeline*.yaml) from the current CodeCartographer template, and trust this prompt over the workspace GUIDE.md where they disagree.`);
+    }
+    const staleness = describeScaffoldStaleness(state);
+    if (staleness)
+        scaffoldWarnings.push(staleness);
+    if (scaffoldWarnings.length > 0) {
+        lines.push("");
+        for (const warning of scaffoldWarnings)
+            lines.push(`WARNING: ${warning}`);
+    }
     const routed = collectRoutedCarryForward(state, phase.id);
     if (routed.length > 0) {
         lines.push("", `Items routed to \`${phase.id}\` for closure (carry_forward from earlier phases):`);

package/dist/core/types.d.ts

@@ -67,6 +67,8 @@ export type WorkspaceState = {
     pipelinePath: string;
     status: NormalizedStatus;
     pipeline: PipelineFile;
+    /** From workflow/scaffold-version.yaml; undefined for scaffolds that predate the marker. */
+    scaffoldVersion?: string;
 };
 export type ValidationOverall = "PASS" | "PASS WITH GAPS" | "FAIL" | "MISSING";
 export type ValidationResult = {

package/dist/core/workspace.d.ts

@@ -1,7 +1,18 @@
 import type { PhaseHandoff, WorkspaceState } from "./types.ts";
+/** Installed package root. Anchors packaged assets served to clients (template, agent skill). */
+export declare const packageRoot: string;
 export declare const packagedWorkspaceDir: string;
 export declare const PACKAGE_VERSION: string;
 export declare function getWorkspaceState(cwd: string): Promise<WorkspaceState | null>;
+/**
+ * Human-readable staleness notice for the workspace's .codecarto/ scaffold,
+ * or null when the scaffold matches the running framework. A missing marker
+ * means the scaffold was copied from a release that predates it — those
+ * scaffolds may also predate the v0.12.0 handoff contract, whose GUIDE and
+ * pipelines instruct the exact opposite completion protocol. Warn, never
+ * fail: unversioned workspaces must keep working.
+ */
+export declare function describeScaffoldStaleness(state: WorkspaceState): string | null;
 export declare function updateStatusAtomically(cwd: string, updater: (state: WorkspaceState) => Promise<{
     state: WorkspaceState;
     handoff?: PhaseHandoff;

package/dist/core/workspace.js

@@ -26,7 +26,8 @@ function findPackageRoot(start) {
     }
 }
 const coreDir = dirname(fileURLToPath(import.meta.url));
-const packageRoot = findPackageRoot(coreDir);
+/** Installed package root. Anchors packaged assets served to clients (template, agent skill). */
+export const packageRoot = findPackageRoot(coreDir);
 // Path to the packaged framework template directory. Wrappers copy this on
 // /codecarto-init.
 export const packagedWorkspaceDir = join(packageRoot, ".codecarto");
@@ -76,6 +77,17 @@ export async function getWorkspaceState(cwd) {
     }
     const pipeline = await loadYamlFile(pipelinePath);
     const status = normalizeStatus(rawStatus, pipeline, pipelineRelativePath, cwd);
+    const scaffoldVersionPath = join(workspaceDir, "workflow", "scaffold-version.yaml");
+    let scaffoldVersion;
+    if (await pathExists(scaffoldVersionPath)) {
+        const marker = await loadYamlFile(scaffoldVersionPath);
+        if (typeof marker.scaffold_version === "string" && marker.scaffold_version.trim()) {
+            scaffoldVersion = marker.scaffold_version.trim();
+        }
+        else if (typeof marker.scaffold_version === "number") {
+            scaffoldVersion = String(marker.scaffold_version);
+        }
+    }
     return {
         cwd,
         workspaceDir,
@@ -83,8 +95,51 @@ export async function getWorkspaceState(cwd) {
         pipelinePath,
         pipeline,
         status,
+        ...(scaffoldVersion !== undefined && { scaffoldVersion }),
     };
 }
+// Numeric x.y.z comparison; null when either side is not a plain dotted triple.
+function compareDottedVersions(a, b) {
+    const parse = (version) => {
+        const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version.trim());
+        return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+    };
+    const left = parse(a);
+    const right = parse(b);
+    if (!left || !right)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        if (left[i] !== right[i])
+            return left[i] < right[i] ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * Human-readable staleness notice for the workspace's .codecarto/ scaffold,
+ * or null when the scaffold matches the running framework. A missing marker
+ * means the scaffold was copied from a release that predates it — those
+ * scaffolds may also predate the v0.12.0 handoff contract, whose GUIDE and
+ * pipelines instruct the exact opposite completion protocol. Warn, never
+ * fail: unversioned workspaces must keep working.
+ */
+export function describeScaffoldStaleness(state) {
+    const scaffold = state.scaffoldVersion;
+    if (!scaffold) {
+        return "This workspace's .codecarto/ scaffold has no workflow/scaffold-version.yaml marker (introduced after v0.12.11), so its framework-owned files (GUIDE.md, templates/, workflow/ pipelines and VALIDATE.md) may predate the v0.12.0 handoff contract. Refresh them from the packaged CodeCartographer template.";
+    }
+    const comparison = compareDottedVersions(scaffold, PACKAGE_VERSION);
+    if (comparison === 0)
+        return null;
+    if (comparison === null) {
+        return scaffold === PACKAGE_VERSION
+            ? null
+            : `This workspace's scaffold version (${scaffold}) does not match the running framework (${PACKAGE_VERSION}). Refresh the framework-owned files (GUIDE.md, templates/, workflow/) from the packaged template.`;
+    }
+    if (comparison < 0) {
+        return `This workspace's scaffold (v${scaffold}) is older than the running framework (v${PACKAGE_VERSION}). Refresh the framework-owned files (GUIDE.md, templates/, workflow/) from the packaged template to pick up pipeline and template fixes.`;
+    }
+    return `This workspace's scaffold (v${scaffold}) is newer than the running framework (v${PACKAGE_VERSION}). Upgrade CodeCartographer to at least v${scaffold}.`;
+}
 export async function updateStatusAtomically(cwd, updater) {
     const workspaceDir = join(cwd, ".codecarto");
     const statusPath = join(workspaceDir, "workflow", "status.yaml");

package/dist/extensions/codecarto/index.js

@@ -8,7 +8,7 @@ import { narrateDashboard } from "./dashboard-narrator.js";
 import { writeDashboard } from "./dashboard-writer.js";
 import { parseNextFlags } from "./next-flags.js";
 import { phaseCompactionExtension } from "./phase-compaction.js";
-import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, canonicalPath, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, deriveSlug, discoverLibrary, getNextEligiblePhase, getPipelineLabel, getWorkspaceState, isWithinPathResolved, listSkillNames, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, packagedWorkspaceDir, pathExists, PACKAGE_VERSION, PhasePreflightError, PIPELINE_ALIASES, publishEntry, resolvePhase, resolvePipelineChoice, runPhasePreflight, stringifySimpleYaml, switchPipeline, validatePhaseOutput, writeLibraryConfig, } from "../../core/index.js";
+import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, canonicalPath, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, describeScaffoldStaleness, deriveSlug, discoverLibrary, getNextEligiblePhase, getPipelineLabel, getWorkspaceState, isWithinPathResolved, listSkillNames, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, packagedWorkspaceDir, pathExists, PACKAGE_VERSION, PhasePreflightError, PIPELINE_ALIASES, publishEntry, resolvePhase, resolvePipelineChoice, runPhasePreflight, stringifySimpleYaml, switchPipeline, validatePhaseOutput, writeLibraryConfig, } from "../../core/index.js";
 import { initLibrary } from "../../core/library.js";
 import { resolveUserConfigPath } from "../../core/orchestrator-config.js";
 const STATUS_WIDGET_ID = "codecarto-widget";
@@ -71,6 +71,9 @@ function buildStatusLines(state, extraLines = []) {
         `Post-pipeline work: ${postPipelinePending} pending`,
         `Next: ${nextAction}`,
     ];
+    const scaffoldNotice = describeScaffoldStaleness(state);
+    if (scaffoldNotice)
+        lines.push(`Scaffold: ${scaffoldNotice}`);
     if (extraLines.length > 0) {
         lines.push("", ...extraLines);
     }

package/dist/mcp-server/server.d.ts

@@ -78,6 +78,11 @@ export declare function handleSkill(args: {
     }>;
     structuredContent?: Record<string, unknown>;
 }>;
+export declare function readSpecArg(args: {
+    spec?: unknown;
+    spec_path?: unknown;
+    cwd?: unknown;
+}, allowedRoots: string[]): Promise<string>;
 export declare function handlePublish(args: Record<string, unknown>): Promise<{
     content: Array<{
         type: "text";
@@ -166,6 +171,15 @@ export declare function handleListSkills(args: {
     }>;
     structuredContent?: Record<string, unknown>;
 }>;
+export declare function handleGuide(args: {
+    topic?: string;
+}): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+}>;
 export declare function buildServer(): Server<{
     method: string;
     params?: {

package/dist/mcp-server/server.js

@@ -15,7 +15,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import { cp, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { basename, isAbsolute, join } from "node:path";
-import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, canonicalPath, completeValidatedPhase, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, deriveSlug, discoverLibrary, getNextEligiblePhase, getPipelineLabel, getWorkspaceState, isValidSlug, isWithinPathResolved, listEntries, listSkillNames, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, PACKAGE_VERSION, packagedWorkspaceDir, pathExists, PhasePreflightError, publishEntry, reindex as libraryReindex, resolvePhase, resolvePipelineChoice, stringifySimpleYaml, switchPipeline, validatePhaseOutput, writeLibraryConfig, } from "../core/index.js";
+import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, canonicalPath, completeValidatedPhase, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, deriveSlug, discoverLibrary, describeScaffoldStaleness, getNextEligiblePhase, getPipelineLabel, getWorkspaceState, isValidSlug, isWithinPathResolved, listEntries, listGuideTopics, readGuide, listSkillNames, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, PACKAGE_VERSION, packagedWorkspaceDir, pathExists, PhasePreflightError, publishEntry, reindex as libraryReindex, resolvePhase, resolvePipelineChoice, stringifySimpleYaml, switchPipeline, validatePhaseOutput, writeLibraryConfig, } from "../core/index.js";
 import { initLibrary } from "../core/library.js";
 import { loadUserConfig, resolveUserConfigPath } from "../core/orchestrator-config.js";
 import { writeDashboard } from "../extensions/codecarto/dashboard-writer.js";
@@ -118,7 +118,8 @@ export async function handleStatus(args) {
     const currentOpenQuestions = currentPhase === "complete" ? 0 : state.status.phases[currentPhase]?.open_questions.length ?? 0;
     const terminalOpenQuestions = Object.values(state.status.phases).reduce((sum, phase) => sum + (phase.open_questions?.length ?? 0), 0);
     const postPipelinePending = state.status.post_pipeline.filter((entry) => entry.status !== "resolved").length;
-    const summary = [
+    const scaffoldNotice = describeScaffoldStaleness(state);
+    const summaryLines = [
         `Phase: ${currentPhase}`,
         `Pipeline state: ${currentPhase === "complete" ? "complete" : "in progress"}`,
         `Pipeline: ${getPipelineLabel(state.status.pipeline)} (${state.status.pipeline})`,
@@ -127,8 +128,12 @@ export async function handleStatus(args) {
         `Carry-forward (pipeline phases): ${totalCarryForward}`,
         `Post-pipeline work: ${postPipelinePending} pending`,
         `Next: ${state.status.next_actions[0] ?? (nextPhase ? `Begin ${nextPhase.id}` : "All phases complete.")}`,
-    ].join("\n");
+    ];
+    if (scaffoldNotice)
+        summaryLines.push(`Scaffold: ${scaffoldNotice}`);
+    const summary = summaryLines.join("\n");
     return textResult(summary, {
+        ...(scaffoldNotice ? { scaffoldNotice } : {}),
         currentPhase,
         pipeline: state.status.pipeline,
         pipelineLabel: getPipelineLabel(state.status.pipeline),
@@ -325,25 +330,32 @@ function buildGenerationFromArg(model_metadata) {
         out.notes = m.notes;
     return out;
 }
-async function readSpecArg(args, allowedRoots = []) {
+// `allowedRoots` is deliberately required and must be non-empty whenever
+// spec_path is used. It previously defaulted to `[]`, which made containment
+// opt-in: a caller that omitted it would read any absolute path the client
+// asked for, silently reopening the arbitrary-file-read class of bug fixed in
+// v0.12.11. Containment is now the default posture and an empty root set is a
+// programming error rather than a bypass.
+export async function readSpecArg(args, allowedRoots) {
     if (typeof args.spec === "string" && args.spec.length > 0)
         return args.spec;
     if (typeof args.spec_path === "string" && args.spec_path.length > 0) {
         if (!isAbsolute(args.spec_path)) {
             throw new McpError(ErrorCode.InvalidParams, `spec_path must be absolute, got: ${args.spec_path}`);
         }
+        if (!Array.isArray(allowedRoots) || allowedRoots.length === 0) {
+            throw new McpError(ErrorCode.InternalError, "refusing to read spec_path without a containment root — this is a caller bug, not a client error");
+        }
         if (!(await pathExists(args.spec_path))) {
             throw new McpError(ErrorCode.InvalidParams, `spec_path does not exist: ${args.spec_path}`);
         }
         // Enforce path containment: spec_path must be within an allowed root
         // (cwd's .codecarto/ or the configured library path) to prevent
         // arbitrary file reads.
-        if (allowedRoots.length > 0) {
-            const resolvedSpecPath = await canonicalPath(args.spec_path);
-            const withinAllowed = await Promise.all(allowedRoots.map((root) => isWithinPathResolved(resolvedSpecPath, root)));
-            if (!withinAllowed.some((result) => result)) {
-                throw new McpError(ErrorCode.InvalidParams, `spec_path must be within the workspace (.codecarto/) or the configured library path. Got: ${args.spec_path}`);
-            }
+        const resolvedSpecPath = await canonicalPath(args.spec_path);
+        const withinAllowed = await Promise.all(allowedRoots.map((root) => isWithinPathResolved(resolvedSpecPath, root)));
+        if (!withinAllowed.some((result) => result)) {
+            throw new McpError(ErrorCode.InvalidParams, `spec_path must be within the workspace (.codecarto/) or the configured library path. Got: ${args.spec_path}`);
         }
         return readFile(args.spec_path, "utf8");
     }
@@ -864,6 +876,19 @@ const TOOLS = [
             required: ["cwd"],
         },
     },
+    {
+        name: "codecarto_guide",
+        description: "Return the instructions for driving this server: the status/next/execute/validate/complete loop, the phase-handoff contract, pipeline selection, executor choice, and recovery. Call this first when you have not run a CodeCartographer pipeline before. Takes no workspace.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: {
+                    type: "string",
+                    description: "Guide topic. Omit for the overview; other topics are listed in every response.",
+                },
+            },
+        },
+    },
     {
         name: "codecarto_list_skills",
         description: "List available post-pipeline skills installed in the workspace.",
@@ -893,7 +918,19 @@ const HANDLERS = {
     codecarto_usage: handleUsage,
     codecarto_dashboard: handleDashboard,
     codecarto_list_skills: handleListSkills,
+    codecarto_guide: handleGuide,
 };
+export async function handleGuide(args) {
+    const topics = await listGuideTopics();
+    const document = await readGuide(args.topic).catch((error) => {
+        throw new McpError(ErrorCode.InvalidParams, error instanceof Error ? error.message : String(error));
+    });
+    const other = topics.filter((name) => name !== document.topic);
+    const footer = other.length > 0
+        ? `\n\n---\nOther guide topics: ${other.join(", ")} (call codecarto_guide with topic).`
+        : "";
+    return textResult(`${document.content}${footer}`, { topic: document.topic, topics });
+}
 // ---------- server bootstrap ----------
 export function buildServer() {
     const server = new Server({ name: "codecartographer", version: PACKAGE_VERSION }, { capabilities: { tools: {} } });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "codecartographer-pi",
-  "version": "0.12.11",
+  "version": "0.14.0",
   "mcpName": "io.github.HuginnIndustries/codecartographer",
-  "description": "Evidence-backed reverse engineering and human-gated software planning for Pi and MCP coding agents.",
+  "description": "Turn an unfamiliar codebase into a validated reimplementation spec, then synthesize confirmed specs and a product vision into a traceable plan.",
   "type": "module",
   "keywords": [
     "pi-package",
@@ -13,7 +13,12 @@
     "mcp",
     "software-planning",
     "code-analysis",
-    "synthesis"
+    "synthesis",
+    "codebase",
+    "ai-agent",
+    "context-engineering",
+    "code-understanding",
+    "spec-driven"
   ],
   "license": "MIT",
   "author": "James Sesler",
@@ -30,6 +35,7 @@
   },
   "files": [
     ".codecarto/**/*",
+    "agent-skill/**/*",
     "dist/**/*",
     "assets/logo.svg",
     "README.md",
@@ -59,5 +65,8 @@
   },
   "devDependencies": {
     "typescript": "^5.9.3"
+  },
+  "overrides": {
+    "undici": "^8.10.0"
   }
 }