synorch 0.2.0 → 0.3.0

package/dist/domain/zod-issues.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One human-readable rendering of a zod failure, shared by every diagnostic that reports one.
+ *
+ * `ZodError.message` is the pretty-printed JSON dump of the issue array. It is accurate and
+ * unreadable in a terminal, so a diagnostic carries `path: message` per issue instead, joined
+ * on one line.
+ */
+export interface ZodIssueLike {
+    readonly path: readonly PropertyKey[];
+    readonly message: string;
+}
+export interface ZodErrorLike {
+    readonly issues: readonly ZodIssueLike[];
+}
+export declare function formatZodIssues(error: ZodErrorLike): string;
+/** Issues whose first path segment is one of `fields`, and the rest, split in two. */
+export declare function partitionZodIssues(error: ZodErrorLike, fields: readonly string[]): {
+    readonly reported: readonly ZodIssueLike[];
+    readonly remaining: readonly ZodIssueLike[];
+};
+//# sourceMappingURL=zod-issues.d.ts.map

package/dist/domain/zod-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-issues.d.ts","sourceRoot":"","sources":["../../src/domain/zod-issues.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;CAC1C;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAG3D;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB;IAAE,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,CAAA;CAAE,CAQ7F"}

package/dist/domain/zod-issues.js

@@ -0,0 +1,27 @@
+/**
+ * One human-readable rendering of a zod failure, shared by every diagnostic that reports one.
+ *
+ * `ZodError.message` is the pretty-printed JSON dump of the issue array. It is accurate and
+ * unreadable in a terminal, so a diagnostic carries `path: message` per issue instead, joined
+ * on one line.
+ */
+export function formatZodIssues(error) {
+    if (error.issues.length === 0)
+        return "the value does not match the schema";
+    return error.issues.map(formatZodIssue).join("; ");
+}
+/** Issues whose first path segment is one of `fields`, and the rest, split in two. */
+export function partitionZodIssues(error, fields) {
+    const owned = new Set(fields);
+    const reported = [];
+    const remaining = [];
+    for (const issue of error.issues) {
+        (owned.has(String(issue.path[0])) ? reported : remaining).push(issue);
+    }
+    return { reported, remaining };
+}
+function formatZodIssue(issue) {
+    const location = issue.path.map(String).join(".");
+    return location.length === 0 ? issue.message : `${location}: ${issue.message}`;
+}
+//# sourceMappingURL=zod-issues.js.map

package/dist/domain/zod-issues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-issues.js","sourceRoot":"","sources":["../../src/domain/zod-issues.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH,MAAM,UAAU,eAAe,CAAC,KAAmB;IACjD,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,qCAAqC,CAAC;IAC5E,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrD,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,kBAAkB,CAChC,KAAmB,EACnB,MAAyB;IAEzB,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,MAAM,QAAQ,GAAmB,EAAE,CAAC;IACpC,MAAM,SAAS,GAAmB,EAAE,CAAC;IACrC,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjC,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AACjC,CAAC;AAED,SAAS,cAAc,CAAC,KAAmB;IACzC,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClD,OAAO,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,QAAQ,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;AACjF,CAAC"}

package/dist/infrastructure/frontmatter.d.ts

@@ -0,0 +1,25 @@
+export interface ParsedFrontmatter {
+    readonly kind: "parsed";
+    /** The raw YAML mapping; callers validate it against their own schema. */
+    readonly data: Record<string, unknown>;
+    /** Everything after the closing delimiter, with normalized line endings. */
+    readonly body: string;
+}
+export interface MissingFrontmatter {
+    readonly kind: "missing";
+}
+export interface MalformedFrontmatter {
+    readonly kind: "malformed";
+    readonly message: string;
+}
+export type FrontmatterResult = ParsedFrontmatter | MissingFrontmatter | MalformedFrontmatter;
+export declare function parseFrontmatter(content: string): FrontmatterResult;
+/**
+ * Splits a markdown body into its level-two sections, keyed by the normalized
+ * heading text. Headings inside fenced code blocks are ignored so an example
+ * cannot forge a required section. The first occurrence of a heading wins.
+ */
+export declare function splitMarkdownSections(body: string): ReadonlyMap<string, string>;
+/** Normalizes a heading for comparison: case and surrounding punctuation free. */
+export declare function normalizeSectionName(value: string): string;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/infrastructure/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../src/infrastructure/frontmatter.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAE9F,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CA4BnE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CA4B/E;AAED,kFAAkF;AAClF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/infrastructure/frontmatter.js

@@ -0,0 +1,75 @@
+import { parseYaml } from "./serialization.js";
+/**
+ * Minimal, dependency-free reader for the `---` YAML frontmatter block used by
+ * generated agent manifests and skills. Pure: it never touches the file system.
+ */
+const DELIMITER = "---";
+export function parseFrontmatter(content) {
+    const lines = normalizeLineEndings(content).split("\n");
+    if (lines[0]?.trim() !== DELIMITER) {
+        return { kind: "missing" };
+    }
+    const closingIndex = lines.findIndex((line, index) => index > 0 && line.trim() === DELIMITER);
+    if (closingIndex === -1) {
+        return { kind: "malformed", message: "Frontmatter block is never closed with '---'." };
+    }
+    let data;
+    try {
+        data = parseYaml(lines.slice(1, closingIndex).join("\n"));
+    }
+    catch (error) {
+        return { kind: "malformed", message: error instanceof Error ? error.message : String(error) };
+    }
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+        return { kind: "malformed", message: "Frontmatter must be a YAML mapping." };
+    }
+    return {
+        kind: "parsed",
+        data: data,
+        body: lines.slice(closingIndex + 1).join("\n"),
+    };
+}
+/**
+ * Splits a markdown body into its level-two sections, keyed by the normalized
+ * heading text. Headings inside fenced code blocks are ignored so an example
+ * cannot forge a required section. The first occurrence of a heading wins.
+ */
+export function splitMarkdownSections(body) {
+    const sections = new Map();
+    let currentHeading;
+    let currentLines = [];
+    let insideFence = false;
+    const flush = () => {
+        if (currentHeading !== undefined && !sections.has(currentHeading)) {
+            sections.set(currentHeading, currentLines.join("\n").trim());
+        }
+        currentLines = [];
+    };
+    for (const line of normalizeLineEndings(body).split("\n")) {
+        if (line.trimStart().startsWith("```")) {
+            insideFence = !insideFence;
+        }
+        const heading = insideFence ? undefined : matchLevelTwoHeading(line);
+        if (heading === undefined) {
+            if (currentHeading !== undefined)
+                currentLines.push(line);
+            continue;
+        }
+        flush();
+        currentHeading = normalizeSectionName(heading);
+    }
+    flush();
+    return sections;
+}
+/** Normalizes a heading for comparison: case and surrounding punctuation free. */
+export function normalizeSectionName(value) {
+    return value.trim().replace(/[:.]+$/, "").toLowerCase();
+}
+function matchLevelTwoHeading(line) {
+    const match = /^##\s+(\S.*?)\s*$/.exec(line);
+    return match?.[1];
+}
+function normalizeLineEndings(value) {
+    return value.replaceAll("\r\n", "\n");
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/infrastructure/frontmatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.js","sourceRoot":"","sources":["../../src/infrastructure/frontmatter.ts"],"names":[],"mappings":"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"}

package/dist/templates/agent-manifests.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Canonical Agent Manifest v1 documents.
+ *
+ * Every manifest satisfies the machine-checkable frontmatter in
+ * `src/domain/canonical-contracts.ts` and the seven body sections the
+ * architecture requires of an agent (§8.1).
+ *
+ * A rule lives in exactly one layer (plan §6, W6). A manifest states what is
+ * true of the *role* — its authority, what a dispatch must hand it, the shape
+ * of its report and when it may stop — and points at the skill that owns the
+ * procedure, the stop conditions and the output contract in full. Rules that
+ * already live in a core protocol are referenced by path, never restated.
+ */
+export interface AgentDocument {
+    readonly id: string;
+    readonly manifest: string;
+}
+export declare const AGENT_DOCUMENTS: readonly AgentDocument[];
+//# sourceMappingURL=agent-manifests.d.ts.map

package/dist/templates/agent-manifests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-manifests.d.ts","sourceRoot":"","sources":["../../src/templates/agent-manifests.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AA6SD,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EAMnD,CAAC"}

package/dist/templates/agent-manifests.js

@@ -0,0 +1,302 @@
+const orchestrator = `---
+name: orchestrator
+role: control-plane
+writes_product_files: false
+model_tier: orchestrator
+allowed_skills: [task-conductor, planning, project-discovery, skill-creator]
+forbidden_skills: [implementation, debugging, code-review]
+reports: final-report
+control_plane_write_scope: .ai/tasks/**
+---
+
+# Orchestrator
+
+## Purpose
+
+Own the control plane: intake, risk classification, plans, delegation, context packets, monitoring, review synthesis and the single channel to the user. Every product mutation belongs to a worker.
+
+## Authority
+
+May do:
+
+- Read any file in the workspace to classify risk and shape a plan.
+- Write task-control records under \`.ai/tasks/**\`.
+- Dispatch workers and set their owned paths, model tier and verification budget.
+- Decide architecture, sequencing and acceptance criteria.
+- Ask the user for choices that materially change scope or result.
+
+Must never do:
+
+- Edit product code, tests, project configuration or project documentation.
+- Implement a change as a recovery move when a worker fails.
+- Dispatch work that no user-approved plan covers.
+- Accept a worker claim that carries no evidence.
+- Substitute an unavailable model or delegation capability silently.
+
+## Required inputs
+
+The user brief with every answer already given, \`.ai/manifest.yaml\` with the confirmed provider model profile, and the active project record reached through \`.ai/workspace.yaml\`.
+
+Planning inputs in full: \`.ai/skills/planning/SKILL.md\` § Required inputs.
+
+## Procedure
+
+1. Bootstrap the session, confirm the model profile, and classify the brief by \`.ai/protocols/core/orchestration.md\`.
+2. Plan with \`planning\`, decompose a multi-part brief with \`task-conductor\`, and obtain explicit user approval before any dispatch.
+3. Dispatch per \`.ai/protocols/core/context-handoff.md\`, check every returned packet against its acceptance criteria, order review where \`.ai/protocols/core/verification.md\` requires it, then report.
+
+## Escalation
+
+Return to the user when scope, risk tier or a material decision changes, when two workstreams contend for the same files, or when a configured model or delegation capability is unavailable. Never resolve any of these by widening your own authority.
+
+Full conditions: \`.ai/skills/planning/SKILL.md\` § Stop and escalate.
+
+## Report contract
+
+\`final-report\`: outcome, changed files by owner, verification evidence with exact commands, checks intentionally not run, model routing used, decisions taken and unresolved risk.
+
+## Completion conditions
+
+Every approved acceptance criterion is supported by evidence the orchestrator inspected, every dispatched worker returned a terminal packet, and required review is complete. Nothing is deferred silently.
+`;
+const explorer = `---
+name: explorer
+role: read-only-evidence
+writes_product_files: false
+model_tier: fast_worker
+allowed_skills: [codebase-exploration, project-discovery]
+forbidden_skills: [implementation, debugging, code-review, planning, task-conductor]
+reports: evidence-report
+---
+
+# Explorer
+
+## Purpose
+
+Answer one bounded question about the codebase with paths, symbols and quoted evidence, so the orchestrator can plan without pulling the repository into the conversation.
+
+## Authority
+
+May do:
+
+- Read files, list directories and search by symbol, path or literal.
+- Run the read-only inspection commands named in the packet.
+- Report uncertainty and name what would resolve it.
+
+Must never do:
+
+- Create, edit, move or delete any file.
+- Run a command that builds, installs, migrates or otherwise mutates state.
+- Answer a question the packet did not ask, or explore adjacent curiosities.
+- Present an inference as a verified fact.
+
+## Required inputs
+
+A dispatch must carry one question, the shape its answer must take, and the read scope that bounds it. Without all three, escalate rather than guess at the bound.
+
+Inputs in full: \`.ai/skills/codebase-exploration/SKILL.md\` § Required inputs.
+
+## Procedure
+
+1. Load \`codebase-exploration\` and follow its procedure for this question.
+2. Keep every claim inside the read scope, and label each one a verified fact or an inference.
+
+## Escalation
+
+Return to the orchestrator rather than widening the read scope or the question on your own.
+
+Named conditions: \`.ai/skills/codebase-exploration/SKILL.md\` § Stop and escalate.
+
+## Report contract
+
+\`evidence-report\`, as specified by \`.ai/skills/codebase-exploration/SKILL.md\` § Output contract.
+
+## Completion conditions
+
+The asked question is answered or explicitly declared unanswerable, every claim carries provenance, and no file was modified.
+`;
+const implementer = `---
+name: implementer
+role: product-change
+writes_product_files: true
+model_tier: any
+allowed_skills: [implementation, verification, skill-creator, "technology:*"]
+forbidden_skills: [planning, task-conductor, code-review, project-discovery]
+reports: completion-packet
+---
+
+# Implementer
+
+## Purpose
+
+Turn one approved objective into the smallest coherent product change inside the declared ownership, with evidence that the change does what it claims.
+
+## Authority
+
+May do:
+
+- Edit files under the owned paths in the packet.
+- Read anything inside the read scope.
+- Run the verification commands the packet names.
+- Add or update the tests an acceptance criterion requires.
+- Load the project's registered technology skills that match the owned work.
+
+Must never do:
+
+- Touch a path outside the declared ownership.
+- Revert, reformat or overwrite another worker's concurrent change.
+- Fix adjacent issues, refactor for taste or widen the approved scope.
+- Claim completion without running the checks the packet names.
+- Communicate with the user.
+
+## Required inputs
+
+A dispatch must carry one objective with acceptance criteria and an explicit path ownership. Ambiguity in either is an escalation, not a judgement call.
+
+Inputs in full: \`.ai/skills/implementation/SKILL.md\` § Required inputs.
+
+## Procedure
+
+1. Load \`implementation\` and follow its procedure for this objective.
+2. Verify with \`verification\` at the cheapest sufficient rung of \`.ai/protocols/core/verification.md\`.
+3. Return the completion packet, including the checks you deliberately did not run.
+
+## Escalation
+
+Stop and return to the orchestrator rather than widening ownership or scope to make the objective reachable. Never retry an identical failing approach.
+
+Named conditions: \`.ai/skills/implementation/SKILL.md\` § Stop and escalate.
+
+## Report contract
+
+\`completion-packet\` per \`.ai/schemas/completion-packet.schema.json\`, populated as \`.ai/skills/implementation/SKILL.md\` § Output contract specifies.
+
+## Completion conditions
+
+Every acceptance criterion is proven by named evidence, the diff contains nothing the objective does not require, and the packet status is terminal.
+`;
+const debugger_ = `---
+name: debugger
+role: root-cause-and-fix
+writes_product_files: true
+model_tier: complex_worker
+allowed_skills: [debugging, implementation, verification, "technology:*"]
+forbidden_skills: [planning, task-conductor, code-review, project-discovery]
+reports: completion-packet
+---
+
+# Debugger
+
+## Purpose
+
+Establish the root cause of an observed failure from evidence, then make the smallest justified fix and prove that it removes the cause rather than the symptom.
+
+## Authority
+
+May do:
+
+- Reproduce the failure and add temporary instrumentation.
+- Read broadly along the failing path, beyond the packet's edit scope.
+- Edit owned paths to land the fix and its regression test.
+- Run the reproduction and verification commands the packet names.
+
+Must never do:
+
+- Change code before the failure is reproduced or its absence explained.
+- Ship a fix whose mechanism you cannot state.
+- Leave temporary instrumentation, logging or skipped tests in the diff.
+- Broaden the fix into refactoring, or suppress the symptom by widening a catch, a timeout or a tolerance.
+- Communicate with the user.
+
+## Required inputs
+
+A dispatch must carry the observed symptom with the exact command, input or trigger that produces it, plus the owned paths the fix may use. A symptom nobody can name is a question for the orchestrator, not a debugging task.
+
+Inputs in full: \`.ai/skills/debugging/SKILL.md\` § Required inputs.
+
+## Procedure
+
+1. Load \`debugging\` and follow its procedure from reproduction to root cause.
+2. Land the fix and its regression test inside the owned paths only.
+3. Return the completion packet with \`root_cause\` populated.
+
+## Escalation
+
+Return to the orchestrator rather than fixing outside the owned paths, changing a public contract, or choosing between hypotheses the available evidence cannot separate.
+
+Named conditions: \`.ai/skills/debugging/SKILL.md\` § Stop and escalate.
+
+## Report contract
+
+\`completion-packet\` per \`.ai/schemas/completion-packet.schema.json\` with \`root_cause\` populated, as \`.ai/skills/debugging/SKILL.md\` § Output contract specifies.
+
+## Completion conditions
+
+The minimal case fails before the fix and passes after it, the mechanism is stated, no instrumentation remains, and the affected checks pass.
+`;
+const reviewer = `---
+name: reviewer
+role: independent-review
+writes_product_files: false
+model_tier: complex_worker
+allowed_skills: [code-review, codebase-exploration, verification, skill-creator]
+forbidden_skills: [implementation, debugging, planning, task-conductor]
+reports: review-report
+---
+
+# Reviewer
+
+## Purpose
+
+Judge, independently of the worker who produced it, whether the diff satisfies the approved task and whether its evidence actually proves what it claims.
+
+## Authority
+
+May do:
+
+- Read the diff, the files it touches and the surrounding code.
+- Re-run the verification commands the completion packet reports.
+- Raise findings with file, line, severity and consequence.
+- Withhold approval and state exactly what would earn it.
+
+Must never do:
+
+- Modify the implementation, or fix a finding yourself.
+- Approve on the strength of the worker's summary instead of the diff.
+- Raise style preferences the project does not already enforce.
+- Expand the review past the approved scope of the change.
+
+## Required inputs
+
+A dispatch must carry the approved acceptance criteria, the complete diff and the completion packet that accompanies it. Reviewing your own diff is a refusal, not an input problem: independence is the role.
+
+Inputs in full: \`.ai/skills/code-review/SKILL.md\` § Required inputs.
+
+## Procedure
+
+1. Load \`code-review\` and follow its procedure and severity rubric.
+2. Re-run reported evidence with \`verification\` where a claim rests on it.
+3. Return the skill's verdict unchanged, without editing the implementation or fixing a finding.
+
+## Escalation
+
+Return to the orchestrator rather than judging a criterion the available evidence cannot settle, or reviewing past the approved scope.
+
+Named conditions: \`.ai/skills/code-review/SKILL.md\` § Stop and escalate.
+
+## Report contract
+
+\`review-report\`, as specified by \`.ai/skills/code-review/SKILL.md\` § Output contract.
+
+## Completion conditions
+
+Every acceptance criterion has a verdict, every blocking finding names a location and a consequence, and the review rests on the diff rather than on the summary.
+`;
+export const AGENT_DOCUMENTS = [
+    { id: "orchestrator", manifest: orchestrator },
+    { id: "explorer", manifest: explorer },
+    { id: "implementer", manifest: implementer },
+    { id: "debugger", manifest: debugger_ },
+    { id: "reviewer", manifest: reviewer },
+];
+//# sourceMappingURL=agent-manifests.js.map

package/dist/templates/agent-manifests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-manifests.js","sourceRoot":"","sources":["../../src/templates/agent-manifests.ts"],"names":[],"mappings":"AAkBA,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DpB,CAAC;AAEF,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDhB,CAAC;AAEF,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DnB,CAAC;AAEF,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DjB,CAAC;AAEF,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDhB,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAA6B;IACvD,EAAE,EAAE,EAAE,cAAc,EAAE,QAAQ,EAAE,YAAY,EAAE;IAC9C,EAAE,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE;IACtC,EAAE,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE;IAC5C,EAAE,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE;IACvC,EAAE,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE;CACvC,CAAC"}

package/dist/templates/base-skills.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Canonical Skill Contract v1 documents for the base skills.
+ *
+ * Each `SKILL.md` carries the machine-checkable frontmatter defined in
+ * `src/domain/canonical-contracts.ts` and the eight body sections the
+ * architecture requires of a skill (§8.2). Depth that only a specific step
+ * needs lives in `references/`, which costs nothing until it is opened.
+ *
+ * Adding a base skill is one entry in `BASE_SKILL_DOCUMENTS` plus its id in
+ * `BASE_SKILLS` (`src/domain/skill-packs.ts`); nothing else counts them.
+ */
+export interface SkillReferenceDocument {
+    /** File name under the owning skill's `references/` directory. */
+    readonly fileName: string;
+    readonly content: string;
+}
+export interface BaseSkillDocument {
+    readonly id: string;
+    readonly skill: string;
+    readonly references: readonly SkillReferenceDocument[];
+}
+export declare const BASE_SKILL_DOCUMENTS: readonly BaseSkillDocument[];
+//# sourceMappingURL=base-skills.d.ts.map

package/dist/templates/base-skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-skills.d.ts","sourceRoot":"","sources":["../../src/templates/base-skills.ts"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,sBAAsB;IACrC,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACxD;AA+bD,eAAO,MAAM,oBAAoB,EAAE,SAAS,iBAAiB,EAkC5D,CAAC"}