@webpresso/agent-kit 0.21.4 → 0.23.0

package/dist/esm/blueprint/service/BlueprintService.js

@@ -11,6 +11,7 @@ import { parseBlueprint } from '#core/parser';
 import { applyBlueprintLifecycleToFile } from '#lifecycle/local';
 import { resolveBlueprintRoot } from '#utils/blueprint-root';
 import { emitTraceArtifact, generateBlueprintLifecycleTrace } from '#utils/decision-trace-artifacts';
+import { getBlueprintDocumentCandidates } from '#utils/document-paths.js';
 import { BlueprintNotFoundError } from '#utils/errors';
 import { computeBlueprintQuerySummary, matchesBlueprintFilters, sortBlueprintRecords, toBlueprintRecord, } from './blueprint-records.js';
 import { linkBlueprintToTechDebt, unlinkBlueprintFromTechDebt, } from './blueprint-tech-debt-links.js';
@@ -74,25 +75,28 @@ export class BlueprintService extends TrackedDocumentService {
     }
     async get(slug) {
         // Try direct path first (supports both 'in-progress/foo' and 'foo')
-        const planPath = path.join(this.baseDir, slug, '_overview.md');
-        try {
-            await fs.access(planPath);
-            const content = await fs.readFile(planPath, 'utf-8');
-            return parseBlueprint(content, slug);
-        }
-        catch {
-            // Scan all plans to find a match by slug
-            const scannedPlans = scanBlueprintDirectory({
-                baseDir: this.baseDir,
-                includeSpecialFolders: true,
-            });
-            const found = scannedPlans.find((p) => p.slug === slug || p.slug.endsWith(`/${slug}`));
-            if (!found) {
-                throw new BlueprintNotFoundError(slug, planPath, scannedPlans.map((p) => p.slug));
+        const directCandidates = getBlueprintDocumentCandidates(this.baseDir, slug);
+        for (const candidate of directCandidates) {
+            try {
+                await fs.access(candidate);
+                const content = await fs.readFile(candidate, 'utf-8');
+                return parseBlueprint(content, slug);
+            }
+            catch {
+                // Keep trying the remaining canonical shapes before falling back to a scan.
             }
-            const content = await fs.readFile(found.path, 'utf-8');
-            return parseBlueprint(content, found.slug);
         }
+        const searchedPath = directCandidates[0] ?? path.join(this.baseDir, slug, '_overview.md');
+        const scannedPlans = scanBlueprintDirectory({
+            baseDir: this.baseDir,
+            includeSpecialFolders: true,
+        });
+        const found = scannedPlans.find((p) => p.slug === slug || p.slug.endsWith(`/${slug}`));
+        if (!found) {
+            throw new BlueprintNotFoundError(slug, searchedPath, scannedPlans.map((p) => p.slug));
+        }
+        const content = await fs.readFile(found.path, 'utf-8');
+        return parseBlueprint(content, found.slug);
     }
     async query(options) {
         const scannedPlans = scanBlueprintDirectory({ baseDir: this.baseDir });
@@ -153,8 +157,22 @@ export class BlueprintService extends TrackedDocumentService {
      * @returns Array of TechDebtRecord objects
      */
     async getLinkedTechDebt(bpSlug) {
-        const blueprintPath = path.join(this.baseDir, bpSlug, '_overview.md');
-        const content = await fs.readFile(blueprintPath, 'utf-8');
+        const directCandidates = getBlueprintDocumentCandidates(this.baseDir, bpSlug);
+        let resolvedBlueprintPath = null;
+        for (const candidate of directCandidates) {
+            try {
+                await fs.access(candidate);
+                resolvedBlueprintPath = candidate;
+                break;
+            }
+            catch {
+                // Keep trying the other canonical shape.
+            }
+        }
+        const filePath = resolvedBlueprintPath ??
+            directCandidates[0] ??
+            path.join(this.baseDir, bpSlug, '_overview.md');
+        const content = await fs.readFile(filePath, 'utf-8');
         const parsed = matter(content);
         const data = JSON.parse(JSON.stringify(parsed.data));
         const linkedTechDebtSlugs = data.linked_tech_debt_slugs ?? [];

package/dist/esm/blueprint/service/scanner.js

@@ -7,10 +7,18 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { resolveBlueprintRoot } from '#utils/blueprint-root';
+import { BLUEPRINT_OVERVIEW_FILENAME, parseBlueprintDocumentRelativePath, } from '#utils/document-paths.js';
+const BLUEPRINT_STATUS_FOLDERS = new Set([
+    'draft',
+    'planned',
+    'parked',
+    'in-progress',
+    'completed',
+    'archived',
+]);
 /** Special folder prefixes that indicate archived/deferred plans */
 const SPECIAL_FOLDERS = ['_completed', '_future', '_deprioritized'];
 /** Standard plan overview filename */
-const OVERVIEW_FILENAME = '_overview.md';
 /**
  * Check if a path component is a special folder.
  */
@@ -28,6 +36,9 @@ function findSpecialFolderType(pathSegments) {
     }
     return undefined;
 }
+function isStatusFolder(name) {
+    return BLUEPRINT_STATUS_FOLDERS.has(name);
+}
 /**
  * Extract the slug and group from a plan path.
  *
@@ -39,15 +50,42 @@ function findSpecialFolderType(pathSegments) {
  * - 'webpresso/blueprints/_completed/old-plan/_overview.md'
  *   -> slug: '_completed/old-plan', group: null (special folder)
  */
-function extractSlugAndGroup(fullPath, baseDir, filePattern = OVERVIEW_FILENAME) {
-    // Get relative path from base directory
+function extractSlugAndGroup(fullPath, baseDir, filePattern = BLUEPRINT_OVERVIEW_FILENAME) {
     const relPath = relative(baseDir, fullPath);
-    // Split into segments and remove the document filename
-    const segments = relPath.split('/').filter((s) => s !== filePattern && s !== '');
+    const canonicalDocument = parseBlueprintDocumentRelativePath(relPath);
+    if (canonicalDocument) {
+        const slug = `${canonicalDocument.state}/${canonicalDocument.slug}`;
+        return {
+            slug,
+            group: canonicalDocument.state,
+        };
+    }
+    const relSegments = relPath.split('/').filter((s) => s !== '');
+    const segments = [...relSegments];
+    if (!segments.length) {
+        return { slug: '', group: null };
+    }
+    if (filePattern === BLUEPRINT_OVERVIEW_FILENAME) {
+        if (segments[segments.length - 1] === filePattern) {
+            segments.pop();
+        }
+    }
+    else if (filePattern.toLowerCase() === 'readme.md') {
+        if (segments[segments.length - 1] === filePattern) {
+            segments.pop();
+        }
+    }
+    else {
+        const last = segments[segments.length - 1] ?? '';
+        if (last === filePattern) {
+            segments[segments.length - 1] = last.replace(/\.md$/i, '');
+        }
+    }
     if (!segments.length) {
         return { slug: '', group: null };
     }
-    // Filter out special folders from the slug calculation for group determination
+    // Filter out archival special folders from group determination. Lifecycle
+    // status folders are part of the public slug and remain valid groups.
     const nonSpecialSegments = segments.filter((s) => !isSpecialFolder(s));
     // The slug is the full path (including special folders)
     const slug = segments.join('/');
@@ -68,7 +106,7 @@ function extractSlugAndGroup(fullPath, baseDir, filePattern = OVERVIEW_FILENAME)
  * Check if an entry should be skipped during directory traversal.
  */
 function shouldSkipEntry(entry) {
-    return entry.startsWith('.') || entry === 'node_modules';
+    return entry.startsWith('.') || entry.startsWith('__') || entry === 'node_modules';
 }
 /**
  * Safely get file stats, returning null on error.
@@ -126,11 +164,22 @@ function processEntry(entry, dir, baseDir, filePattern, includeSpecialFolders, r
         }
         return;
     }
+    if (filePattern === BLUEPRINT_OVERVIEW_FILENAME &&
+        entry.endsWith('.md') &&
+        entry !== 'README.md') {
+        const relativeParentSegments = relative(baseDir, dir).split('/').filter((s) => s !== '');
+        if (relativeParentSegments.length === 1 && isStatusFolder(relativeParentSegments[0] ?? '')) {
+            const plan = processPlanFile(fullPath, baseDir, includeSpecialFolders, entry);
+            if (plan) {
+                results.push(plan);
+            }
+        }
+    }
 }
 /**
  * Process a plan file (_overview.md or _overview.md) and create a ScannedBlueprint if applicable.
  */
-function processPlanFile(fullPath, baseDir, includeSpecialFolders, filePattern = OVERVIEW_FILENAME) {
+function processPlanFile(fullPath, baseDir, includeSpecialFolders, filePattern = BLUEPRINT_OVERVIEW_FILENAME) {
     const relativePath = relative(baseDir, fullPath);
     // Skip files in hidden directories (defense-in-depth check)
     if (containsHiddenDirectory(relativePath)) {
@@ -192,6 +241,21 @@ export function scanDocumentDirectory(options) {
     }
     const results = [];
     scanDirectory(absoluteBaseDir, absoluteBaseDir, filePattern, includeSpecialFolders, results);
+    const duplicates = new Map();
+    for (const result of results) {
+        const existing = duplicates.get(result.slug);
+        if (existing) {
+            existing.push(result.path);
+        }
+        else {
+            duplicates.set(result.slug, [result.path]);
+        }
+    }
+    const duplicate = Array.from(duplicates.entries()).find(([, paths]) => paths.length > 1);
+    if (duplicate) {
+        const [slug, paths] = duplicate;
+        throw new Error(`Duplicate blueprint slug "${slug}" found in multiple canonical shapes: ${paths.join(', ')}`);
+    }
     return results;
 }
 /**
@@ -205,7 +269,7 @@ export function scanBlueprintDirectory(options) {
     const includeSpecialFolders = options?.includeSpecialFolders ?? false;
     return scanDocumentDirectory({
         baseDir,
-        filePattern: OVERVIEW_FILENAME,
+        filePattern: BLUEPRINT_OVERVIEW_FILENAME,
         includeSpecialFolders,
     });
 }

package/dist/esm/blueprint/tracked-document/schema.d.ts

@@ -18,8 +18,8 @@ export declare const trackedDocumentStatusSchema: z.ZodEnum<{
     completed: "completed";
     draft: "draft";
     planned: "planned";
-    "in-progress": "in-progress";
     parked: "parked";
+    "in-progress": "in-progress";
     archived: "archived";
 }>;
 export type TrackedDocumentStatus = z.infer<typeof trackedDocumentStatusSchema>;
@@ -54,8 +54,8 @@ export declare const trackedDocumentFrontmatterSchema: z.ZodObject<{
         completed: "completed";
         draft: "draft";
         planned: "planned";
-        "in-progress": "in-progress";
         parked: "parked";
+        "in-progress": "in-progress";
         archived: "archived";
     }>;
     last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;

package/dist/esm/blueprint/utils/document-paths.d.ts

@@ -0,0 +1,23 @@
+export declare const BLUEPRINT_OVERVIEW_FILENAME = "_overview.md";
+export declare const BLUEPRINT_STATUSES: readonly ["draft", "planned", "parked", "in-progress", "completed", "archived"];
+export type BlueprintStatus = (typeof BLUEPRINT_STATUSES)[number];
+export type BlueprintShape = 'flat' | 'folder';
+export interface BlueprintDocumentPath {
+    relativePath: string;
+    shape: BlueprintShape;
+    slug: string;
+    state: BlueprintStatus;
+}
+export declare function normalizeBlueprintPath(filePath: string): string;
+export declare function isBlueprintStatus(value: string | undefined): value is BlueprintStatus;
+export declare function isBlueprintSlugSegment(value: string | undefined): value is string;
+export declare function parseBlueprintDocumentRelativePath(filePath: string): BlueprintDocumentPath | null;
+export declare function isBlueprintSupportingMarkdownRelativePath(filePath: string): boolean;
+export declare function getBlueprintDocumentPaths(root: string, state: BlueprintStatus, slug: string): {
+    directory: string;
+    flat: string;
+    folder: string;
+};
+export declare function getBlueprintDocumentCandidates(root: string, slug: string): string[];
+export declare function getBlueprintAlternateDocumentPath(root: string, filePath: string): string | null;
+//# sourceMappingURL=document-paths.d.ts.map

package/dist/esm/blueprint/utils/document-paths.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+export const BLUEPRINT_OVERVIEW_FILENAME = '_overview.md';
+export const BLUEPRINT_STATUSES = [
+    'draft',
+    'planned',
+    'parked',
+    'in-progress',
+    'completed',
+    'archived',
+];
+const BLUEPRINT_STATUS_SET = new Set(BLUEPRINT_STATUSES);
+const BLUEPRINT_SLUG_SEGMENT_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export function normalizeBlueprintPath(filePath) {
+    return filePath.replace(/\\/g, '/').replace(/^\/+/, '');
+}
+export function isBlueprintStatus(value) {
+    return value !== undefined && BLUEPRINT_STATUS_SET.has(value);
+}
+export function isBlueprintSlugSegment(value) {
+    return value !== undefined && BLUEPRINT_SLUG_SEGMENT_PATTERN.test(value);
+}
+export function parseBlueprintDocumentRelativePath(filePath) {
+    const normalized = normalizeBlueprintPath(filePath);
+    const parts = normalized.split('/').filter((segment) => segment.length > 0);
+    const [state, second, third] = parts;
+    if (!isBlueprintStatus(state)) {
+        return null;
+    }
+    if (parts.length === 2 && typeof second === 'string' && second.endsWith('.md')) {
+        const slug = second.slice(0, -3);
+        if (!isBlueprintSlugSegment(slug)) {
+            return null;
+        }
+        return {
+            relativePath: `${state}/${slug}.md`,
+            shape: 'flat',
+            slug,
+            state,
+        };
+    }
+    if (parts.length === 3 &&
+        isBlueprintSlugSegment(second) &&
+        third === BLUEPRINT_OVERVIEW_FILENAME) {
+        return {
+            relativePath: `${state}/${second}/${BLUEPRINT_OVERVIEW_FILENAME}`,
+            shape: 'folder',
+            slug: second,
+            state,
+        };
+    }
+    return null;
+}
+export function isBlueprintSupportingMarkdownRelativePath(filePath) {
+    const normalized = normalizeBlueprintPath(filePath);
+    const parts = normalized.split('/').filter((segment) => segment.length > 0);
+    const [state, slug, doc] = parts;
+    return (parts.length === 3 &&
+        isBlueprintStatus(state) &&
+        isBlueprintSlugSegment(slug) &&
+        typeof doc === 'string' &&
+        doc.endsWith('.md') &&
+        doc !== BLUEPRINT_OVERVIEW_FILENAME);
+}
+export function getBlueprintDocumentPaths(root, state, slug) {
+    const directory = path.join(root, state, slug);
+    return {
+        directory,
+        flat: path.join(root, state, `${slug}.md`),
+        folder: path.join(directory, BLUEPRINT_OVERVIEW_FILENAME),
+    };
+}
+export function getBlueprintDocumentCandidates(root, slug) {
+    const normalized = normalizeBlueprintPath(slug);
+    const segments = normalized.split('/').filter((segment) => segment.length > 0);
+    const [state, name] = segments;
+    if (segments.length !== 2 || !isBlueprintStatus(state) || !isBlueprintSlugSegment(name)) {
+        return [];
+    }
+    const { flat, folder } = getBlueprintDocumentPaths(root, state, name);
+    return [flat, folder];
+}
+export function getBlueprintAlternateDocumentPath(root, filePath) {
+    const normalized = normalizeBlueprintPath(path.relative(root, filePath));
+    const parsed = parseBlueprintDocumentRelativePath(normalized);
+    if (!parsed) {
+        return null;
+    }
+    const paths = getBlueprintDocumentPaths(root, parsed.state, parsed.slug);
+    return parsed.shape === 'flat' ? paths.folder : paths.flat;
+}
+//# sourceMappingURL=document-paths.js.map

package/dist/esm/blueprint/utils/package-assets.d.ts

@@ -3,4 +3,15 @@
  * package root) is found. Works whether running from src/ or dist/esm/.
  */
 export declare function resolvePackageAsset(relativeFromRoot: string): string;
+/**
+ * Resolve the first existing candidate, in priority order. Use when an asset
+ * lives at one path in the source checkout but a different path in the
+ * published tarball — e.g. templates authored under repo-root `docs/templates/`
+ * but shipped under `catalog/docs/templates/` because the npm `files` list
+ * includes `catalog/` and not `docs/`. Prefers the dev/source location and
+ * falls back to the shipped one, mirroring `bin/_run.js`'s source→built path
+ * translation. Falls back to cwd-relative on the first candidate when none
+ * exist, matching `resolvePackageAsset`'s last-resort behavior.
+ */
+export declare function resolvePackageAssetPreferred(candidates: readonly string[]): string;
 //# sourceMappingURL=package-assets.d.ts.map

package/dist/esm/blueprint/utils/package-assets.js

@@ -1,10 +1,10 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 /**
- * Walk up from this file's location until the given path (relative to the
- * package root) is found. Works whether running from src/ or dist/esm/.
+ * Walk up from this file's location looking for `relativeFromRoot`. Returns the
+ * first existing match, or `null` if none is found within the ancestor budget.
  */
-export function resolvePackageAsset(relativeFromRoot) {
+function findPackageAsset(relativeFromRoot) {
     let dir = path.dirname(new URL(import.meta.url).pathname);
     for (let i = 0; i < 8; i++) {
         const candidate = path.join(dir, relativeFromRoot);
@@ -15,6 +15,35 @@ export function resolvePackageAsset(relativeFromRoot) {
             break;
         dir = parent;
     }
-    return path.join(process.cwd(), relativeFromRoot);
+    return null;
+}
+/**
+ * Walk up from this file's location until the given path (relative to the
+ * package root) is found. Works whether running from src/ or dist/esm/.
+ */
+export function resolvePackageAsset(relativeFromRoot) {
+    return findPackageAsset(relativeFromRoot) ?? path.join(process.cwd(), relativeFromRoot);
+}
+/**
+ * Resolve the first existing candidate, in priority order. Use when an asset
+ * lives at one path in the source checkout but a different path in the
+ * published tarball — e.g. templates authored under repo-root `docs/templates/`
+ * but shipped under `catalog/docs/templates/` because the npm `files` list
+ * includes `catalog/` and not `docs/`. Prefers the dev/source location and
+ * falls back to the shipped one, mirroring `bin/_run.js`'s source→built path
+ * translation. Falls back to cwd-relative on the first candidate when none
+ * exist, matching `resolvePackageAsset`'s last-resort behavior.
+ */
+export function resolvePackageAssetPreferred(candidates) {
+    for (const relativeFromRoot of candidates) {
+        const found = findPackageAsset(relativeFromRoot);
+        if (found)
+            return found;
+    }
+    const primary = candidates[0];
+    if (primary === undefined) {
+        throw new Error('resolvePackageAssetPreferred requires at least one candidate path');
+    }
+    return path.join(process.cwd(), primary);
 }
 //# sourceMappingURL=package-assets.js.map

package/dist/esm/build/package-manifest.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import { join } from 'node:path';
 import { parse as parseYaml } from 'yaml';
+import { RUNTIME_TARGETS } from './runtime-targets.js';
 const DEPENDENCY_SECTIONS = [
     'dependencies',
     'devDependencies',
@@ -74,6 +75,12 @@ export function createPackedManifest(manifest, workspaceCatalogs) {
     if ('bin' in packedManifest) {
         packedManifest.bin = normalizePackedBinField(packedManifest.bin);
     }
+    if (typeof manifest.version === 'string') {
+        packedManifest.optionalDependencies = {
+            ...packedManifest.optionalDependencies,
+            ...Object.fromEntries(RUNTIME_TARGETS.map((target) => [target.packageName, manifest.version])),
+        };
+    }
     return packedManifest;
 }
 function writeJson(filePath, value) {

package/dist/esm/build/release-policy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Release-time policy decisions for the publish pipeline.
+ *
+ * The per-platform native runtime packages (`@webpresso/agent-kit-runtime-*`)
+ * are a deferred capability: they are not yet created on the registry, the main
+ * package declares no `optionalDependencies` on them, and the plugin manifest
+ * still launches via the node entrypoint rather than a staged native `bin/wp`.
+ *
+ * Until that native-distribution work is intentionally activated, the release
+ * MUST NOT attempt to publish the matrix: a first-time `npm publish` of a
+ * never-created scoped package returns 404, which previously aborted the entire
+ * release before the main `@webpresso/agent-kit` package published (the root
+ * cause of the 0.22.x publish stall).
+ *
+ * The matrix publish is therefore gated behind an explicit opt-in. When the
+ * native-distribution feature lands, the release workflow sets
+ * `WP_PUBLISH_RUNTIME_MATRIX=1` (after bootstrapping the scoped packages on the
+ * registry) to turn it back on.
+ */
+export declare const PUBLISH_RUNTIME_MATRIX_ENV = "WP_PUBLISH_RUNTIME_MATRIX";
+/**
+ * Whether the release pipeline should build, stage, and publish the per-platform
+ * native runtime matrix. Defaults to `false` (matrix deferred); enabled only
+ * when `WP_PUBLISH_RUNTIME_MATRIX=1` is set explicitly.
+ */
+export declare function shouldPublishRuntimeMatrix(env: NodeJS.ProcessEnv): boolean;
+//# sourceMappingURL=release-policy.d.ts.map

package/dist/esm/build/release-policy.js

@@ -0,0 +1,29 @@
+/**
+ * Release-time policy decisions for the publish pipeline.
+ *
+ * The per-platform native runtime packages (`@webpresso/agent-kit-runtime-*`)
+ * are a deferred capability: they are not yet created on the registry, the main
+ * package declares no `optionalDependencies` on them, and the plugin manifest
+ * still launches via the node entrypoint rather than a staged native `bin/wp`.
+ *
+ * Until that native-distribution work is intentionally activated, the release
+ * MUST NOT attempt to publish the matrix: a first-time `npm publish` of a
+ * never-created scoped package returns 404, which previously aborted the entire
+ * release before the main `@webpresso/agent-kit` package published (the root
+ * cause of the 0.22.x publish stall).
+ *
+ * The matrix publish is therefore gated behind an explicit opt-in. When the
+ * native-distribution feature lands, the release workflow sets
+ * `WP_PUBLISH_RUNTIME_MATRIX=1` (after bootstrapping the scoped packages on the
+ * registry) to turn it back on.
+ */
+export const PUBLISH_RUNTIME_MATRIX_ENV = 'WP_PUBLISH_RUNTIME_MATRIX';
+/**
+ * Whether the release pipeline should build, stage, and publish the per-platform
+ * native runtime matrix. Defaults to `false` (matrix deferred); enabled only
+ * when `WP_PUBLISH_RUNTIME_MATRIX=1` is set explicitly.
+ */
+export function shouldPublishRuntimeMatrix(env) {
+    return env[PUBLISH_RUNTIME_MATRIX_ENV] === '1';
+}
+//# sourceMappingURL=release-policy.js.map

package/dist/esm/build/runtime-targets.d.ts

@@ -0,0 +1,13 @@
+export interface RuntimeTarget {
+    readonly id: string;
+    readonly bunTarget: string;
+    readonly os: NodeJS.Platform;
+    readonly cpu: NodeJS.Architecture;
+    readonly packageName: string;
+}
+export declare const RUNTIME_BINARY_NAME = "wp";
+export declare const RUNTIME_TARGETS: readonly RuntimeTarget[];
+export declare function runtimeBinaryFilename(target: RuntimeTarget): string;
+export declare function runtimePackageDirName(packageName: string): string;
+export declare function resolveRuntimeTarget(platform?: NodeJS.Platform, arch?: NodeJS.Architecture): RuntimeTarget | undefined;
+//# sourceMappingURL=runtime-targets.d.ts.map

package/dist/esm/build/runtime-targets.js

@@ -0,0 +1,48 @@
+export const RUNTIME_BINARY_NAME = 'wp';
+export const RUNTIME_TARGETS = [
+    {
+        id: 'darwin-arm64',
+        bunTarget: 'bun-darwin-arm64',
+        os: 'darwin',
+        cpu: 'arm64',
+        packageName: '@webpresso/agent-kit-runtime-darwin-arm64',
+    },
+    {
+        id: 'darwin-x64',
+        bunTarget: 'bun-darwin-x64',
+        os: 'darwin',
+        cpu: 'x64',
+        packageName: '@webpresso/agent-kit-runtime-darwin-x64',
+    },
+    {
+        id: 'linux-x64',
+        bunTarget: 'bun-linux-x64',
+        os: 'linux',
+        cpu: 'x64',
+        packageName: '@webpresso/agent-kit-runtime-linux-x64',
+    },
+    {
+        id: 'linux-arm64',
+        bunTarget: 'bun-linux-arm64',
+        os: 'linux',
+        cpu: 'arm64',
+        packageName: '@webpresso/agent-kit-runtime-linux-arm64',
+    },
+    {
+        id: 'windows-x64',
+        bunTarget: 'bun-windows-x64',
+        os: 'win32',
+        cpu: 'x64',
+        packageName: '@webpresso/agent-kit-runtime-windows-x64',
+    },
+];
+export function runtimeBinaryFilename(target) {
+    return target.os === 'win32' ? `${RUNTIME_BINARY_NAME}.exe` : RUNTIME_BINARY_NAME;
+}
+export function runtimePackageDirName(packageName) {
+    return packageName.split('/').at(-1) ?? packageName;
+}
+export function resolveRuntimeTarget(platform = process.platform, arch = process.arch) {
+    return RUNTIME_TARGETS.find((target) => target.os === platform && target.cpu === arch);
+}
+//# sourceMappingURL=runtime-targets.js.map

package/dist/esm/build/sync-catalog-doc-templates.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+/**
+ * sync-catalog-doc-templates.ts
+ *
+ * `docs/templates/` (repo root) is the editable source of truth for the
+ * blueprint / doc templates. `catalog/docs/templates/` is the published +
+ * scaffolded mirror: the npm `files` list ships `catalog/` but NOT repo-root
+ * `docs/` (which holds internal docs that must stay private), and `wp init`
+ * scaffolds templates into a consumer from `catalog/docs/templates/`.
+ *
+ * The two MUST stay byte-identical. Nothing synced them before, so they
+ * drifted — this script regenerates the mirror from the source and is wired
+ * into the build. The colocated drift test fails CI if they ever diverge.
+ *
+ * Default: regenerate the mirror from the source.
+ * `--check`: exit non-zero and list drift without writing (CI / pre-publish).
+ */
+/**
+ * Names that are out of sync between source and mirror: content mismatch,
+ * missing from the mirror, or orphaned in the mirror.
+ */
+export declare function diffDocTemplateMirror(): string[];
+//# sourceMappingURL=sync-catalog-doc-templates.d.ts.map