@multileaf/ai-workflow 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project are documented in this file. The format follows Keep a Changelog, and versions follow Semantic Versioning.
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-04
+
+### Added
+
+- Portable installation and migration across Codex, Claude Code, Cursor, Gemini CLI, GitHub Copilot, and a universal target.
+- Hybrid deterministic and AI-assisted project scanning, recommendations, personalization, and confirmation workflows.
+- Spec-driven brainstorming, requirements, decisions, implementation planning, verification, quality gates, and traceability.
+- Versioned packages, registries, Vercel Skills integration, policy enforcement, integrity verification, and update workflows.
+- Layered context, token budgets, opt-in telemetry, plugin SDK, local dashboard, and provider-neutral multi-agent orchestration.
+
+### Security
+
+- Path confinement, symlink protection, explicit permission gates, secret redaction, strict parsers, atomic migrations, and immutable execution checkpoints.
+
+[Unreleased]: https://github.com/MultiLeaf/aiw/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/MultiLeaf/aiw/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MultiLeaf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# AI Workflow
+
+Portable spec-driven development workflow for AI coding agents.
+
+## Installation
+
+```bash
+npx @multileaf/ai-workflow install --target codex
+```
+
+Replace `codex` with `claude`, `cursor`, `gemini`, `copilot`, or `universal` when needed. Every command follows `npx @multileaf/ai-workflow <command> <options>`.
+
+## Development
+
+```bash
+npm install
+npm run build
+node dist/cli.js install --target codex
+node dist/cli.js ui
+```
+
+The project configuration lives in `.aiw/`; target-specific files are generated by adapters.
+
+Telemetry is disabled by default. Use `aiw telemetry status`, `enable`, or `disable` to manage explicit privacy preferences. See [Telemetry and Privacy](docs/telemetry.md).
+
+Create portable plugins with `aiw plugin create` and validate them with `aiw plugin validate`. The typed SDK is exported from `@multileaf/ai-workflow/plugin-sdk`; see [Plugin Authoring](docs/plugin-authoring.md).
+
+Inspect project state in the local dashboard with `aiw ui`. It binds to `127.0.0.1`, loads only `.aiw/` project state, and requires explicit confirmation before target migration.
+
+Preview a versioned multi-agent task graph with `aiw orchestrate --plan=orchestration.yml`. Execution is opt-in through `--execute`, uses a host-provided agent adapter, limits concurrency with `--max-parallel`, and records results under `.aiw/checkpoints/`. The scheduler and adapter contract are exported from `@multileaf/ai-workflow/orchestration`; see [Multi-agent Orchestration](docs/orchestration.md).
+
+Release candidates must pass `npm run release:check`. AI Workflow is available under the MIT License.

package/dist/adapter-contract.d.ts

@@ -0,0 +1,13 @@
+import { type ResourceType } from "./package-contract.js";
+import { type Target } from "./types.js";
+export declare const LIFECYCLE_EVENTS: readonly ["install", "update", "remove", "validate"];
+export type LifecycleEvent = (typeof LIFECYCLE_EVENTS)[number];
+export type AdapterCapabilities = {
+    target: Target;
+    resources: ResourceType[];
+    events: LifecycleEvent[];
+    fallback: boolean;
+};
+export declare const ADAPTER_CAPABILITIES: Readonly<Record<Target, AdapterCapabilities>>;
+export declare function getAdapterCapabilities(target: string): AdapterCapabilities;
+export declare function serializeAdapterCapabilities(target: string): string;

package/dist/adapter-contract.js

@@ -0,0 +1,50 @@
+import { RESOURCE_TYPES } from "./package-contract.js";
+import { TARGETS } from "./types.js";
+export const LIFECYCLE_EVENTS = ["install", "update", "remove", "validate"];
+export const ADAPTER_CAPABILITIES = {
+    codex: {
+        target: "codex",
+        resources: [...RESOURCE_TYPES],
+        events: [...LIFECYCLE_EVENTS],
+        fallback: false,
+    },
+    claude: {
+        target: "claude",
+        resources: ["skills", "rules", "agents", "hooks", "templates"],
+        events: [...LIFECYCLE_EVENTS],
+        fallback: false,
+    },
+    cursor: {
+        target: "cursor",
+        resources: ["skills", "rules", "agents", "hooks", "templates"],
+        events: [...LIFECYCLE_EVENTS],
+        fallback: false,
+    },
+    gemini: {
+        target: "gemini",
+        resources: ["skills", "rules", "agents", "hooks", "templates"],
+        events: [...LIFECYCLE_EVENTS],
+        fallback: false,
+    },
+    copilot: {
+        target: "copilot",
+        resources: ["skills", "rules", "agents", "hooks", "templates"],
+        events: [...LIFECYCLE_EVENTS],
+        fallback: false,
+    },
+    universal: {
+        target: "universal",
+        resources: [...RESOURCE_TYPES],
+        events: [...LIFECYCLE_EVENTS],
+        fallback: true,
+    },
+};
+export function getAdapterCapabilities(target) {
+    if (!TARGETS.includes(target))
+        throw new Error(`Unsupported adapter target: ${target}`);
+    return ADAPTER_CAPABILITIES[target];
+}
+export function serializeAdapterCapabilities(target) {
+    const capabilities = getAdapterCapabilities(target);
+    return `target: ${capabilities.target}\nresources: [${capabilities.resources.join(", ")}]\nevents: [${capabilities.events.join(", ")}]\nfallback: ${capabilities.fallback}\n`;
+}

package/dist/adapter.d.ts

@@ -0,0 +1,15 @@
+import { type Target, type FileSystem } from "./types.js";
+import type { ResourceType } from "./package-contract.js";
+export declare function isTarget(value: string): value is Target;
+export declare function detectTarget(root: string, fs: FileSystem): Target | undefined;
+export declare function generateAiInit(root: string, target: string, fs: FileSystem): void;
+export declare function renderAiInitPath(target: Target): string;
+export declare function renderResourcePath(target: Target, type: ResourceType, id: string): string;
+export type AdapterResourceType = ResourceType | "context";
+export type AdapterSupport = "native" | "compatibility" | "fallback";
+export type AdapterResourceDescriptor = {
+    path: string;
+    support: AdapterSupport;
+};
+export declare function describeResource(target: Target, type: AdapterResourceType, id: string): AdapterResourceDescriptor;
+export declare function renderCodexResource(type: ResourceType, id: string, content: string, root: string, fs: FileSystem): string;

package/dist/adapter.js

@@ -0,0 +1,62 @@
+import { join } from "node:path";
+import { TARGETS } from "./types.js";
+import { getAdapterCapabilities } from "./adapter-contract.js";
+import { describeCodexResource } from "./codex-layout.js";
+import { describeClaudeResource } from "./claude-layout.js";
+import { describeCursorResource } from "./cursor-layout.js";
+import { describeGeminiResource } from "./gemini-layout.js";
+import { describeCopilotResource } from "./copilot-layout.js";
+import { describeUniversalResource } from "./universal-layout.js";
+export function isTarget(value) {
+    return TARGETS.includes(value);
+}
+export function detectTarget(root, fs) {
+    const markers = [
+        ["codex", ".agents"],
+        ["claude", ".claude"],
+        ["cursor", ".cursor"],
+        ["gemini", ".gemini"],
+        ["copilot", ".github/copilot-instructions.md"],
+    ];
+    return markers.find(([, marker]) => fs.exists(join(root, marker)))?.[0];
+}
+export function generateAiInit(root, target, fs) {
+    if (!isTarget(target))
+        throw new Error(`Unsupported target: ${target}`);
+    getAdapterCapabilities(target);
+    fs.write(join(root, renderAiInitPath(target)), `---\nname: ai-init\ndescription: Analyze the project and configure AI Workflow.\n---\n\n# AI Init\n\nAnalyze the repository safely and recommend project-specific capabilities.\n\n## Language Policy\n\nAll generated AI Workflow artifacts must be written in English unless the user explicitly requests another language.\n`);
+}
+export function renderAiInitPath(target) {
+    const paths = {
+        codex: ".agents/skills/ai-init/SKILL.md",
+        claude: ".claude/skills/ai-init/SKILL.md",
+        cursor: ".cursor/skills/ai-init/SKILL.md",
+        gemini: ".gemini/skills/ai-init/SKILL.md",
+        copilot: ".github/copilot-instructions.md",
+        universal: ".aiw/resources/skills/ai-init.md",
+    };
+    return paths[target];
+}
+export function renderResourcePath(target, type, id) {
+    return describeResource(target, type, id).path;
+}
+export function describeResource(target, type, id) {
+    if (!isTarget(target))
+        throw new Error(`Adapter rendering is not implemented for target: ${target}`);
+    if (target === "codex")
+        return describeCodexResource(type, id);
+    if (target === "claude")
+        return describeClaudeResource(type, id);
+    if (target === "cursor")
+        return describeCursorResource(type, id);
+    if (target === "gemini")
+        return describeGeminiResource(type, id);
+    if (target === "copilot")
+        return describeCopilotResource(type, id);
+    return describeUniversalResource(type, id);
+}
+export function renderCodexResource(type, id, content, root, fs) {
+    const path = renderResourcePath("codex", type, id);
+    fs.write(join(root, path), content);
+    return path;
+}

package/dist/claude-layout.d.ts

@@ -0,0 +1,9 @@
+import type { ResourceType } from "./package-contract.js";
+import type { FileSystem } from "./types.js";
+export type ClaudeResourceType = ResourceType | "context";
+export type ClaudeResourceDescriptor = {
+    path: string;
+    support: "native" | "compatibility";
+};
+export declare function describeClaudeResource(type: ClaudeResourceType, id: string): ClaudeResourceDescriptor;
+export declare function renderClaudeContext(root: string, content: string, fs: FileSystem): string;

package/dist/claude-layout.js

@@ -0,0 +1,23 @@
+import { join } from "node:path";
+export function describeClaudeResource(type, id) {
+    const native = {
+        skills: `.claude/skills/${id}/SKILL.md`,
+        rules: `.claude/rules/${id}.md`,
+        agents: `.claude/agents/${id}.md`,
+        context: "CLAUDE.md",
+    };
+    if (native[type])
+        return { path: native[type], support: "native" };
+    const compatibility = {
+        hooks: `.claude/aiw/hooks/${id}.md`,
+        templates: `.claude/aiw/templates/${id}.md`,
+    };
+    if (compatibility[type])
+        return { path: compatibility[type], support: "compatibility" };
+    throw new Error(`Unsupported Claude resource type: ${type}`);
+}
+export function renderClaudeContext(root, content, fs) {
+    const path = describeClaudeResource("context", "project").path;
+    fs.write(join(root, path), content);
+    return path;
+}

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { type WorkflowServices } from "./workflow.js";
+import type { CommandResult } from "./types.js";
+export declare function run(args: string[], root?: string, services?: WorkflowServices): Promise<CommandResult>;

package/dist/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { nodeFileSystem } from "./files.js";
+import { runCommand } from "./workflow.js";
+import { recordConfiguredTelemetry } from "./telemetry.js";
+import { join } from "node:path";
+import { startDashboard } from "./dashboard.js";
+export function run(args, root = process.cwd(), services = {}) {
+    return runWithTelemetry(args, root, services);
+}
+async function runWithTelemetry(args, root, services) {
+    const dependencies = {
+        dashboard: {
+            start: (dashboardRoot, port) => startDashboard(dashboardRoot, nodeFileSystem, (commandArgs) => runCommand(commandArgs, dashboardRoot, nodeFileSystem, services), port),
+        },
+        ...services,
+    };
+    const result = await runCommand(args, root, nodeFileSystem, dependencies);
+    if (args[0] === "ui" || (args[0] === "telemetry" && result.exitCode !== 0))
+        return result;
+    await recordConfiguredTelemetry(nodeFileSystem, join(root, ".aiw/telemetry.yml"), services.telemetry, args[0], result);
+    return result;
+}
+if (process.argv[1]?.endsWith("cli.js") || process.argv[1]?.endsWith("/aiw")) {
+    const result = await run(process.argv.slice(2));
+    if (result.output)
+        console.log(result.output);
+    if (result.error)
+        console.error(result.error);
+    process.exitCode = result.exitCode;
+}

package/dist/codex-layout.d.ts

@@ -0,0 +1,10 @@
+import type { ResourceType } from "./package-contract.js";
+import type { FileSystem } from "./types.js";
+export type CodexResourceType = ResourceType | "context";
+export type CodexSupport = "native" | "compatibility";
+export type CodexResourceDescriptor = {
+    path: string;
+    support: CodexSupport;
+};
+export declare function describeCodexResource(type: CodexResourceType, id: string): CodexResourceDescriptor;
+export declare function renderCodexContext(root: string, content: string, fs: FileSystem): string;

package/dist/codex-layout.js

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+const COMPATIBILITY_ROOTS = {
+    rules: ".agents/rules",
+    agents: ".agents/agents",
+    hooks: ".agents/hooks",
+    templates: ".agents/templates",
+};
+export function describeCodexResource(type, id) {
+    if (type === "skills")
+        return { path: `.agents/skills/${id}/SKILL.md`, support: "native" };
+    if (type === "context")
+        return { path: "AGENTS.md", support: "native" };
+    if (!(type in COMPATIBILITY_ROOTS))
+        throw new Error(`Unsupported Codex resource type: ${type}`);
+    return {
+        path: `${COMPATIBILITY_ROOTS[type]}/${id}/${id}.md`,
+        support: "compatibility",
+    };
+}
+export function renderCodexContext(root, content, fs) {
+    const descriptor = describeCodexResource("context", "project");
+    fs.write(join(root, descriptor.path), content);
+    return descriptor.path;
+}

package/dist/confirmation.d.ts

@@ -0,0 +1,9 @@
+import type { EvidenceFact } from "./evidence.js";
+export type FactOverride = {
+    key: string;
+    action: "accept" | "reject" | "edit";
+    value?: string;
+};
+export declare function serializeOverrides(overrides: FactOverride[]): string;
+export declare function parseOverrides(content: string): FactOverride[];
+export declare function applyOverrides(facts: EvidenceFact[], overrides: FactOverride[]): EvidenceFact[];

package/dist/confirmation.js

@@ -0,0 +1,41 @@
+export function serializeOverrides(overrides) {
+    return `schema: 1\noverrides:\n${overrides.map((item) => `  - key: ${item.key}\n    action: ${item.action}${item.value ? `\n    value: ${item.value}` : ""}`).join("\n")}\n`;
+}
+export function parseOverrides(content) {
+    const overrides = [];
+    const blocks = content.split(/(?=\s{2}- key:)/).slice(1);
+    for (const block of blocks) {
+        const key = block.match(/key: (.+)/)?.[1]?.trim();
+        const action = block.match(/action: (accept|reject|edit)/)?.[1];
+        const value = block.match(/value: (.+)/)?.[1]?.trim();
+        if (key && action)
+            overrides.push({ key, action, ...(value ? { value } : {}) });
+    }
+    return overrides;
+}
+export function applyOverrides(facts, overrides) {
+    return facts.flatMap((fact) => {
+        const override = overrides.find((item) => item.key === fact.key);
+        if (!override || override.action === "accept")
+            return [
+                {
+                    ...fact,
+                    ...(override ? { state: "confirmed", method: "user-confirmed" } : {}),
+                },
+            ];
+        if (override.action === "reject")
+            return [];
+        if (!override.value)
+            throw new Error(`An edited fact requires a value: ${fact.key}`);
+        return [
+            {
+                ...fact,
+                value: override.value,
+                state: "confirmed",
+                method: "user-confirmed",
+                confidence: 1,
+                evidence: [],
+            },
+        ];
+    });
+}

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const WORKFLOW_DIRECTORY = ".aiw";
+export declare const BASE_DIRECTORIES: string[];
+export declare const INSTALL_USAGE = "aiw install [--target target] | scan | status | target <target> | validate";

package/dist/constants.js

@@ -0,0 +1,10 @@
+export const WORKFLOW_DIRECTORY = ".aiw";
+export const BASE_DIRECTORIES = [
+    "checkpoints",
+    "generated/specs",
+    "generated/plans",
+    "generated/docs",
+    "generated/artifacts",
+    "context",
+];
+export const INSTALL_USAGE = "aiw install [--target target] | scan | status | target <target> | validate";

package/dist/context-cache.d.ts

@@ -0,0 +1,8 @@
+export type ContextSummaryCache = {
+    sourceChecksum: string;
+    summary: string;
+};
+export declare function createSummaryCache(source: string, summary: string): ContextSummaryCache;
+export declare function isSummaryFresh(source: string, cache: ContextSummaryCache): boolean;
+export declare function serializeSummaryCache(cache: ContextSummaryCache): string;
+export declare function parseSummaryCache(content: string): ContextSummaryCache;

package/dist/context-cache.js

@@ -0,0 +1,17 @@
+import { checksumPackage } from "./package-integrity.js";
+export function createSummaryCache(source, summary) {
+    return { sourceChecksum: checksumPackage(source), summary };
+}
+export function isSummaryFresh(source, cache) {
+    return checksumPackage(source) === cache.sourceChecksum;
+}
+export function serializeSummaryCache(cache) {
+    return `schema: 1\nsource_checksum: ${cache.sourceChecksum}\nsummary: ${JSON.stringify(cache.summary)}\n`;
+}
+export function parseSummaryCache(content) {
+    const sourceChecksum = content.match(/^source_checksum:\s*(.+)$/m)?.[1]?.trim();
+    const summary = content.match(/^summary:\s*(.+)$/m)?.[1];
+    if (!sourceChecksum || summary === undefined)
+        throw new Error("Invalid context summary cache.");
+    return { sourceChecksum, summary: JSON.parse(summary) };
+}

package/dist/context-quality.d.ts

@@ -0,0 +1,11 @@
+import type { ContextStore } from "./context-store.js";
+export type ContextQuality = {
+    layers: number;
+    nonEmptyLayers: number;
+    characters: number;
+    estimatedTokens: number;
+    uniqueLines: number;
+    duplicateLines: number;
+};
+export declare function measureContextQuality(store: ContextStore): ContextQuality;
+export declare function serializeContextQuality(metrics: ContextQuality): string;

package/dist/context-quality.js

@@ -0,0 +1,27 @@
+export function measureContextQuality(store) {
+    const values = Object.values(store.layers);
+    const lines = values.flatMap((value) => value
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean));
+    const uniqueLines = new Set(lines).size;
+    return {
+        layers: values.length,
+        nonEmptyLayers: values.filter((value) => value.trim()).length,
+        characters: values.join("\n").length,
+        estimatedTokens: Math.ceil(values.join("\n").length / 4),
+        uniqueLines,
+        duplicateLines: lines.length - uniqueLines,
+    };
+}
+export function serializeContextQuality(metrics) {
+    return ([
+        "schema: 1",
+        `layers: ${metrics.layers}`,
+        `non_empty_layers: ${metrics.nonEmptyLayers}`,
+        `characters: ${metrics.characters}`,
+        `estimated_tokens: ${metrics.estimatedTokens}`,
+        `unique_lines: ${metrics.uniqueLines}`,
+        `duplicate_lines: ${metrics.duplicateLines}`,
+    ].join("\n") + "\n");
+}

package/dist/context-retrieval.d.ts

@@ -0,0 +1,3 @@
+import type { ContextStore } from "./context-store.js";
+export declare function retrieveTaskContext(store: ContextStore): string;
+export declare function loadContextDelta(previous: string, current: string): string;

package/dist/context-retrieval.js

@@ -0,0 +1,13 @@
+export function retrieveTaskContext(store) {
+    return ["global", "project", "task"]
+        .map((layer) => store.layers[layer].trim())
+        .filter(Boolean)
+        .join("\n\n");
+}
+export function loadContextDelta(previous, current) {
+    const known = new Set(previous.split("\n"));
+    return current
+        .split("\n")
+        .filter((line) => line && !known.has(line))
+        .join("\n");
+}

package/dist/context-store.d.ts

@@ -0,0 +1,9 @@
+import type { FileSystem } from "./types.js";
+export declare const CONTEXT_LAYERS: readonly ["global", "project", "task", "session"];
+export type ContextLayer = (typeof CONTEXT_LAYERS)[number];
+export type ContextStore = {
+    layers: Record<ContextLayer, string>;
+};
+export declare function readContextStore(root: string, fs: FileSystem): ContextStore;
+export declare function writeContextLayer(root: string, fs: FileSystem, layer: ContextLayer, content: string): void;
+export declare function composeContext(store: ContextStore): string;

package/dist/context-store.js

@@ -0,0 +1,18 @@
+import { join } from "node:path";
+export const CONTEXT_LAYERS = ["global", "project", "task", "session"];
+export function readContextStore(root, fs) {
+    const layers = Object.fromEntries(CONTEXT_LAYERS.map((layer) => {
+        const path = join(root, ".aiw/context", `${layer}.md`);
+        return [layer, fs.exists(path) ? fs.read(path) : ""];
+    }));
+    return { layers };
+}
+export function writeContextLayer(root, fs, layer, content) {
+    fs.mkdir(join(root, ".aiw/context"));
+    fs.write(join(root, ".aiw/context", `${layer}.md`), content.endsWith("\n") ? content : `${content}\n`);
+}
+export function composeContext(store) {
+    return CONTEXT_LAYERS.filter((layer) => store.layers[layer].trim())
+        .map((layer) => `# ${layer} context\n\n${store.layers[layer].trim()}`)
+        .join("\n\n");
+}

package/dist/copilot-layout.d.ts

@@ -0,0 +1,9 @@
+import type { ResourceType } from "./package-contract.js";
+import type { FileSystem } from "./types.js";
+export type CopilotResourceType = ResourceType | "context";
+export type CopilotResourceDescriptor = {
+    path: string;
+    support: "native" | "compatibility";
+};
+export declare function describeCopilotResource(type: CopilotResourceType, id: string): CopilotResourceDescriptor;
+export declare function renderCopilotContext(root: string, content: string, fs: FileSystem): string;

package/dist/copilot-layout.js

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+export function describeCopilotResource(type, id) {
+    if (type === "skills")
+        return { path: `.github/skills/${id}/SKILL.md`, support: "native" };
+    if (type === "rules")
+        return { path: `.github/instructions/${id}.instructions.md`, support: "native" };
+    if (type === "agents")
+        return { path: `.github/agents/${id}.md`, support: "native" };
+    if (type === "context")
+        return { path: ".github/copilot-instructions.md", support: "native" };
+    const roots = {
+        hooks: ".github/aiw/hooks",
+        templates: ".github/aiw/templates",
+    };
+    const root = roots[type];
+    if (!root)
+        throw new Error(`Unsupported Copilot resource type: ${type}`);
+    return { path: `${root}/${id}.md`, support: "compatibility" };
+}
+export function renderCopilotContext(root, content, fs) {
+    const path = describeCopilotResource("context", "project").path;
+    fs.write(join(root, path), content);
+    return path;
+}

package/dist/cursor-layout.d.ts

@@ -0,0 +1,9 @@
+import type { ResourceType } from "./package-contract.js";
+import type { FileSystem } from "./types.js";
+export type CursorResourceType = ResourceType | "context";
+export type CursorResourceDescriptor = {
+    path: string;
+    support: "native" | "compatibility";
+};
+export declare function describeCursorResource(type: CursorResourceType, id: string): CursorResourceDescriptor;
+export declare function renderCursorContext(root: string, content: string, fs: FileSystem): string;

package/dist/cursor-layout.js

@@ -0,0 +1,25 @@
+import { join } from "node:path";
+export function describeCursorResource(type, id) {
+    if (type === "rules")
+        return { path: `.cursor/rules/${id}.mdc`, support: "native" };
+    if (type === "context")
+        return { path: "AGENTS.md", support: "native" };
+    const roots = {
+        skills: ".cursor/skills",
+        agents: ".cursor/aiw/agents",
+        hooks: ".cursor/aiw/hooks",
+        templates: ".cursor/aiw/templates",
+    };
+    const root = roots[type];
+    if (!root)
+        throw new Error(`Unsupported Cursor resource type: ${type}`);
+    return {
+        path: type === "skills" ? `${root}/${id}/SKILL.md` : `${root}/${id}.md`,
+        support: "compatibility",
+    };
+}
+export function renderCursorContext(root, content, fs) {
+    const path = describeCursorResource("context", "project").path;
+    fs.write(join(root, path), content);
+    return path;
+}

package/dist/dashboard.d.ts

@@ -0,0 +1,37 @@
+import type { FileSystem } from "./types.js";
+export type DashboardFact = {
+    key: string;
+    value: string;
+    state: string;
+    confidence: string;
+};
+export type DashboardRecommendation = {
+    id: string;
+    provider: string;
+    selected: boolean;
+};
+export type DashboardTrace = {
+    requirement: string;
+    decisions: string[];
+    tasks: string[];
+    evidence: string[];
+};
+export type DashboardModel = {
+    project: string;
+    target: string;
+    facts: DashboardFact[];
+    recommendations: DashboardRecommendation[];
+    traceability: DashboardTrace[];
+};
+export type DashboardCommand = (args: string[]) => Promise<{
+    exitCode: number;
+    output?: string;
+    error?: string;
+}>;
+export type DashboardHandle = {
+    url: string;
+    close(): Promise<void>;
+};
+export declare function buildDashboardModel(root: string, fs: FileSystem): DashboardModel;
+export declare function renderDashboard(model: DashboardModel, notice?: string): string;
+export declare function startDashboard(root: string, fs: FileSystem, execute: DashboardCommand, port?: number): Promise<DashboardHandle>;