@autonomos/core 0.3.3 → 0.5.0

package/README.md

@@ -8,8 +8,9 @@ This package contains the shared constants, types, templates, and parsers that d
 
 ## Features
 
-- **Constants**: Shared directory and file names (`.autonomos`, `manifest.json`, etc.)
+- **Constants**: Shared directory and file names (`.autonomos`, `manifest.json`, optional `specs/`, and `decisions/`)
 - **Templates**: Immutable templates for `PROTOCOL.md`, `TASKS.md`, `AGENT.md`, and `manifest.json`.
+- **Knowledge boundaries**: Markdown-first conventions for optional specifications and decision records (ADR), without requiring a parser.
 - **Types**: TypeScript definitions for protocol entities (Tasks, Agents, Manifest).
 - **Parsers**: Tools for extracting structured data from markdown (e.g., `TaskParser`).
 
@@ -28,6 +29,7 @@ const tasks = TaskParser.parse(markdownContent)
 - `src/constants.ts`: Global constants and versioning.
 - `src/types.ts`: Core type definitions.
 - `src/templates/`: Protocol file templates.
+- `src/workflows/`: Distributed harness workflow sources, including `/adopt` for reviewable legacy-knowledge migration.
 - `src/parsers/`: Logic for parsing protocol files.
 
 ## License

package/dist/index.d.mts

@@ -5,7 +5,7 @@ import { z } from "zod";
  * Agent Protocol Specification Version (Independent of Package versions)
  * This refers to the schema and behavioral contract version.
  */
-declare const PROTOCOL_VERSION = "0.3.1-alpha";
+declare const PROTOCOL_VERSION = "0.5.0-alpha";
 /**
  * Directory name for Autonomos configuration
  */
@@ -30,6 +30,14 @@ declare const AGENT_FILE = "AGENT.md";
  * Worklogs directory name
  */
 declare const WORKLOGS_DIR = "worklogs";
+/**
+ * Optional project-owned directory for durable target-state specifications
+ */
+declare const SPECS_DIR = "specs";
+/**
+ * Optional project-owned directory for technical decision records (ADRs)
+ */
+declare const DECISIONS_DIR = "decisions";
 //#endregion
 //#region src/schemas/harness-codes.d.ts
 /**
@@ -37,7 +45,7 @@ declare const WORKLOGS_DIR = "worklogs";
  *
  * At least one of `workflowsDir`, `targetDir`, or `skillsDir` must be defined.
  *
- * - `workflowsDir`: Where session.md, task.md, crystallize.md are written.
+ * - `workflowsDir`: Where the protocol workflow files are written.
  *    Preferred field — used by most harnesses.
  * - `targetDir`: Single directory (legacy, like Cline's .clinerules/workflows/).
  * - `skillsDir`: Skills directory (legacy, for harnesses that don't distinguish
@@ -347,19 +355,19 @@ declare function parseManifest(content: string): Manifest;
 //#endregion
 //#region src/templates/protocol.d.ts
 /**
- * The Protocol kernel template — v0.3
+ * The Protocol kernel template — v0.5
  *
- * Design principles (v0.3):
+ * Design principles (v0.5):
  * - PROTOCOL.md is a compact REFERENCE, not an executable workflow.
- * - All step-by-step instructions live in the 3 workflow files.
+ * - All step-by-step instructions live in the workflow files.
  * - No duplication between PROTOCOL.md and workflows.
  * - Short enough that an LLM can re-scan it mid-session without cost.
  */
-declare const PROTOCOL_TEMPLATE = "# AUTONOMOS PROTOCOL (v0.3.1-alpha)\n\n> This file defines the project's AI workflow contract. The workflows execute it. Do not duplicate workflow steps here.\n\n## Quick Reference\n\n| Action | How |\n|---|---|\n| Start a session | Read the `/session` workflow |\n| Start a task | Read the `/task` workflow |\n| End a session | Read the `/crystallize` workflow |\n| Get context | Read `AGENT.md` (root \u2192 local) |\n| Find all AGENT.md | `find . -name AGENT.md -not -path '*/node_modules/*'` |\n| Pick next task | Open `.autonomos/TASKS.md`, pick highest priority not `[x]` |\n| Log session work | Create `.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md` |\n\n## File Map\n\n| File | Location | Role |\n|---|---|---|\n| `AGENT.md` | Root + any subdirectory | Fractal knowledge base (context, preferences, stack) |\n| `TASKS.md` | `.autonomos/TASKS.md` | Single source of truth for task state |\n| `worklogs/` | `.autonomos/worklogs/` | Session history (one file per session) |\n| `PROTOCOL.md` | `.autonomos/PROTOCOL.md` | This file \u2014 read-only reference |\n| `manifest.json` | `.autonomos/manifest.json` | Protocol version metadata |\n\n## AGENT.md Format Rules\n\n**Root `AGENT.md`** \u2014 Must use the structured template (frontmatter + sections: Context, Workflow, Stack, Key Directories, Constraints).\n\n**Local `AGENT.md`** (in any subdirectory) \u2014 Free format. One line is enough if it is clear. What matters: the next session can use it. Example:\n\n```markdown\n# AGENT: packages/core\n- Stack: TypeScript, Vitest, tsdown\n- Conventions: exports via src/index.ts, tests co-located (*.test.ts)\n- Constraint: template changes require workflow test updates\n```\n\n## Task Format\n\n`- [Status] **[ID]** Title \\`Priority\\` \\`Complexity\\``\n\n| Status | Priority | Complexity |\n|---|---|---|\n| `[ ]` Todo | `\uD83D\uDD34 Critical` | `S` Small |\n| `[/]` In Progress | `\uD83D\uDFE0 High` | `M` Medium |\n| `[x]` Done | `\uD83D\uDD35 Medium` | `L` Large |\n| `[!]` Blocked | `\u26AA Low` | `XL` Huge |\n\n## Metadata Rules\n\n- **Language:** English unless AGENT.md says otherwise.\n- **Tone:** Technical, concise, fact-based.\n- **Continuity:** Refer to previous work as \"we\" or \"the project\".\n";
+declare const PROTOCOL_TEMPLATE = "# AUTONOMOS PROTOCOL (v0.5.0-alpha)\n\n> This file defines the project's AI workflow contract. The workflows execute it. Do not duplicate workflow steps here.\n\n## Quick Reference\n\n| Action                           | How                                                                                |\n| -------------------------------- | ---------------------------------------------------------------------------------- |\n| Start a session                  | Read the `/session` workflow                                                       |\n| Start a task                     | Read the `/task` workflow                                                          |\n| Triage a problem or proposal     | Read the optional `/issue` workflow                                                |\n| Adopt existing project knowledge | Read the optional `/adopt` workflow                                                |\n| Audit accumulated drift          | Read the `/reconcile` workflow                                                     |\n| End a session                    | Read the `/crystallize` workflow                                                   |\n| Get context                      | Read root `AGENT.md`, then only the selected scope's ancestor chain                |\n| Resolve objective                | Explicit user request first; otherwise resume `[/]` or pick highest-priority `[ ]` |\n| Log session work                 | Create `.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md`                               |\n\n## File Map\n\n| File            | Location                   | Role                                              |\n| --------------- | -------------------------- | ------------------------------------------------- |\n| `AGENT.md`      | Root + any subdirectory    | Durable guidance for its directory scope          |\n| `TASKS.md`      | `.autonomos/TASKS.md`      | Single source of truth for task state             |\n| `ISSUES.md`     | `.autonomos/ISSUES.md`     | Optional problem, proposal, and question intake   |\n| `worklogs/`     | `.autonomos/worklogs/`     | Historical session evidence, not current guidance |\n| `specs/`        | `.autonomos/specs/`        | Optional project-owned normative target state     |\n| `decisions/`    | `.autonomos/decisions/`    | Optional project-owned decision records (ADRs)    |\n| `PROTOCOL.md`   | `.autonomos/PROTOCOL.md`   | This file \u2014 read-only reference                   |\n| `manifest.json` | `.autonomos/manifest.json` | Protocol version metadata                         |\n\n## AGENT.md Format Rules\n\nStore only stable guidance that will affect different future tasks. Keep transient evidence in worklogs and operational explanations in component documentation. Use the narrowest applicable `AGENT.md`; consolidate or replace obsolete entries instead of appending history.\n\n**Root `AGENT.md`** \u2014 Must use the structured template (frontmatter + sections: Context, Workflow, Stack, Key Directories, Constraints).\n\n**Local `AGENT.md`** (in any subdirectory) \u2014 Free format. One line is enough if it is clear. What matters: the next session can use it. Example:\n\n```markdown\n# AGENT: packages/core\n\n- Stack: TypeScript, Vitest, tsdown\n- Conventions: exports via src/index.ts, tests co-located (\\*.test.ts)\n- Constraint: template changes require workflow test updates\n```\n\n## Issue, Specification, Decision, and Task Rules\n\nIssues describe evidence, impact, and a desired outcome without choosing implementation; proposed directions remain hypotheses until an approach is accepted. Specifications describe accepted target behavior or requirements that may guide multiple tasks. A decision record (commonly ADR, Architecture Decision Record) captures one technical choice and its rationale. Tasks describe an accepted intervention and completion criteria. Use optional `ISSUES.md`, `specs/`, and `decisions/` only when they provide value; direct, clear changes may become tasks immediately. Link related issues, specs, decisions, and tasks in both directions.\n\n## Specification and Decision Rules\n\n- `.autonomos/specs/` and `.autonomos/decisions/` are optional, project-owned, first-use directories; `init`, `update`, and artifact-integrity checks do not create or overwrite them.\n- Keep one Markdown file per bounded specification or decision. Include status, scope, provenance, acceptance criteria or consequences, and replacement links where relevant; no parser or independent version is required initially.\n- Specification status is `draft`, `accepted`, or `superseded`. Only `accepted` is normative; `superseded` points to its successor. Acceptance does not mean implementation is complete.\n- Decision records use `proposed`, `accepted`, or `superseded`; they preserve rationale and alternatives rather than duplicating the full specification.\n- Keep stable agent operating rules in `AGENT.md`, user/developer reference in `docs/`, execution state in `TASKS.md`, and historical evidence in `worklogs/`.\n- Read only relevant accepted records at task start. Use `/adopt` to extract legacy knowledge; never rewrite historical worklogs, issues, or tasks to create current artifacts.\n\nThe protocol-facing name is **decision record**. **ADR** (Architecture Decision Record) is a common convention for the same kind of document, not a required external standard. Use these lightweight Markdown shapes as a starting point; they are conventions, not parser-enforced schemas:\n\n```markdown\n# SPEC-001 \u2014 Concise target-state title\n\n- Status: draft | accepted | superseded\n- Scope: component, capability, or boundary\n- Provenance: issue, discussion, or source links\n- Related decisions: ADR-001, ...\n- Superseded by: SPEC-002 (when applicable)\n\n## Intent\n\n## Requirements\n\n## Acceptance criteria\n\n## Out of scope\n```\n\n```markdown\n# ADR-001 \u2014 Concise decision title\n\n- Status: proposed | accepted | superseded\n- Scope: component or technical boundary\n- Provenance: issue, task, or investigation links\n- Related specs: SPEC-001, ...\n- Superseded by: ADR-002 (when applicable)\n\n## Context\n\n## Decision\n\n## Alternatives considered\n\n## Consequences\n```\n\nOnly user/project governance accepts a specification or decision as normative. Agents may draft and link records, but must not silently promote them; acceptance is separate from implementation completion.\n\n## Task Format\n\n`- [Status] **[ID]** Title \\`Priority\\` \\`Complexity\\``\n\n| Status            | Priority      | Complexity |\n| ----------------- | ------------- | ---------- |\n| `[ ]` Todo        | `\uD83D\uDD34 Critical` | `S` Small  |\n| `[/]` In Progress | `\uD83D\uDFE0 High`     | `M` Medium |\n| `[x]` Done        | `\uD83D\uDD35 Medium`   | `L` Large  |\n| `[!]` Blocked     | `\u26AA Low`      | `XL` Huge  |\n\n## Metadata Rules\n\n- **Language:** English unless AGENT.md says otherwise.\n- **Tone:** Technical, concise, fact-based.\n- **Continuity:** Refer to previous work as \"we\" or \"the project\".\n";
 /**
  * @deprecated Use PROTOCOL_TEMPLATE instead
  */
-declare const PROTOCOL_TEMPLATE_V2026_1 = "# AUTONOMOS PROTOCOL (v0.3.1-alpha)\n\n> This file defines the project's AI workflow contract. The workflows execute it. Do not duplicate workflow steps here.\n\n## Quick Reference\n\n| Action | How |\n|---|---|\n| Start a session | Read the `/session` workflow |\n| Start a task | Read the `/task` workflow |\n| End a session | Read the `/crystallize` workflow |\n| Get context | Read `AGENT.md` (root \u2192 local) |\n| Find all AGENT.md | `find . -name AGENT.md -not -path '*/node_modules/*'` |\n| Pick next task | Open `.autonomos/TASKS.md`, pick highest priority not `[x]` |\n| Log session work | Create `.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md` |\n\n## File Map\n\n| File | Location | Role |\n|---|---|---|\n| `AGENT.md` | Root + any subdirectory | Fractal knowledge base (context, preferences, stack) |\n| `TASKS.md` | `.autonomos/TASKS.md` | Single source of truth for task state |\n| `worklogs/` | `.autonomos/worklogs/` | Session history (one file per session) |\n| `PROTOCOL.md` | `.autonomos/PROTOCOL.md` | This file \u2014 read-only reference |\n| `manifest.json` | `.autonomos/manifest.json` | Protocol version metadata |\n\n## AGENT.md Format Rules\n\n**Root `AGENT.md`** \u2014 Must use the structured template (frontmatter + sections: Context, Workflow, Stack, Key Directories, Constraints).\n\n**Local `AGENT.md`** (in any subdirectory) \u2014 Free format. One line is enough if it is clear. What matters: the next session can use it. Example:\n\n```markdown\n# AGENT: packages/core\n- Stack: TypeScript, Vitest, tsdown\n- Conventions: exports via src/index.ts, tests co-located (*.test.ts)\n- Constraint: template changes require workflow test updates\n```\n\n## Task Format\n\n`- [Status] **[ID]** Title \\`Priority\\` \\`Complexity\\``\n\n| Status | Priority | Complexity |\n|---|---|---|\n| `[ ]` Todo | `\uD83D\uDD34 Critical` | `S` Small |\n| `[/]` In Progress | `\uD83D\uDFE0 High` | `M` Medium |\n| `[x]` Done | `\uD83D\uDD35 Medium` | `L` Large |\n| `[!]` Blocked | `\u26AA Low` | `XL` Huge |\n\n## Metadata Rules\n\n- **Language:** English unless AGENT.md says otherwise.\n- **Tone:** Technical, concise, fact-based.\n- **Continuity:** Refer to previous work as \"we\" or \"the project\".\n";
+declare const PROTOCOL_TEMPLATE_V2026_1 = "# AUTONOMOS PROTOCOL (v0.5.0-alpha)\n\n> This file defines the project's AI workflow contract. The workflows execute it. Do not duplicate workflow steps here.\n\n## Quick Reference\n\n| Action                           | How                                                                                |\n| -------------------------------- | ---------------------------------------------------------------------------------- |\n| Start a session                  | Read the `/session` workflow                                                       |\n| Start a task                     | Read the `/task` workflow                                                          |\n| Triage a problem or proposal     | Read the optional `/issue` workflow                                                |\n| Adopt existing project knowledge | Read the optional `/adopt` workflow                                                |\n| Audit accumulated drift          | Read the `/reconcile` workflow                                                     |\n| End a session                    | Read the `/crystallize` workflow                                                   |\n| Get context                      | Read root `AGENT.md`, then only the selected scope's ancestor chain                |\n| Resolve objective                | Explicit user request first; otherwise resume `[/]` or pick highest-priority `[ ]` |\n| Log session work                 | Create `.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md`                               |\n\n## File Map\n\n| File            | Location                   | Role                                              |\n| --------------- | -------------------------- | ------------------------------------------------- |\n| `AGENT.md`      | Root + any subdirectory    | Durable guidance for its directory scope          |\n| `TASKS.md`      | `.autonomos/TASKS.md`      | Single source of truth for task state             |\n| `ISSUES.md`     | `.autonomos/ISSUES.md`     | Optional problem, proposal, and question intake   |\n| `worklogs/`     | `.autonomos/worklogs/`     | Historical session evidence, not current guidance |\n| `specs/`        | `.autonomos/specs/`        | Optional project-owned normative target state     |\n| `decisions/`    | `.autonomos/decisions/`    | Optional project-owned decision records (ADRs)    |\n| `PROTOCOL.md`   | `.autonomos/PROTOCOL.md`   | This file \u2014 read-only reference                   |\n| `manifest.json` | `.autonomos/manifest.json` | Protocol version metadata                         |\n\n## AGENT.md Format Rules\n\nStore only stable guidance that will affect different future tasks. Keep transient evidence in worklogs and operational explanations in component documentation. Use the narrowest applicable `AGENT.md`; consolidate or replace obsolete entries instead of appending history.\n\n**Root `AGENT.md`** \u2014 Must use the structured template (frontmatter + sections: Context, Workflow, Stack, Key Directories, Constraints).\n\n**Local `AGENT.md`** (in any subdirectory) \u2014 Free format. One line is enough if it is clear. What matters: the next session can use it. Example:\n\n```markdown\n# AGENT: packages/core\n\n- Stack: TypeScript, Vitest, tsdown\n- Conventions: exports via src/index.ts, tests co-located (\\*.test.ts)\n- Constraint: template changes require workflow test updates\n```\n\n## Issue, Specification, Decision, and Task Rules\n\nIssues describe evidence, impact, and a desired outcome without choosing implementation; proposed directions remain hypotheses until an approach is accepted. Specifications describe accepted target behavior or requirements that may guide multiple tasks. A decision record (commonly ADR, Architecture Decision Record) captures one technical choice and its rationale. Tasks describe an accepted intervention and completion criteria. Use optional `ISSUES.md`, `specs/`, and `decisions/` only when they provide value; direct, clear changes may become tasks immediately. Link related issues, specs, decisions, and tasks in both directions.\n\n## Specification and Decision Rules\n\n- `.autonomos/specs/` and `.autonomos/decisions/` are optional, project-owned, first-use directories; `init`, `update`, and artifact-integrity checks do not create or overwrite them.\n- Keep one Markdown file per bounded specification or decision. Include status, scope, provenance, acceptance criteria or consequences, and replacement links where relevant; no parser or independent version is required initially.\n- Specification status is `draft`, `accepted`, or `superseded`. Only `accepted` is normative; `superseded` points to its successor. Acceptance does not mean implementation is complete.\n- Decision records use `proposed`, `accepted`, or `superseded`; they preserve rationale and alternatives rather than duplicating the full specification.\n- Keep stable agent operating rules in `AGENT.md`, user/developer reference in `docs/`, execution state in `TASKS.md`, and historical evidence in `worklogs/`.\n- Read only relevant accepted records at task start. Use `/adopt` to extract legacy knowledge; never rewrite historical worklogs, issues, or tasks to create current artifacts.\n\nThe protocol-facing name is **decision record**. **ADR** (Architecture Decision Record) is a common convention for the same kind of document, not a required external standard. Use these lightweight Markdown shapes as a starting point; they are conventions, not parser-enforced schemas:\n\n```markdown\n# SPEC-001 \u2014 Concise target-state title\n\n- Status: draft | accepted | superseded\n- Scope: component, capability, or boundary\n- Provenance: issue, discussion, or source links\n- Related decisions: ADR-001, ...\n- Superseded by: SPEC-002 (when applicable)\n\n## Intent\n\n## Requirements\n\n## Acceptance criteria\n\n## Out of scope\n```\n\n```markdown\n# ADR-001 \u2014 Concise decision title\n\n- Status: proposed | accepted | superseded\n- Scope: component or technical boundary\n- Provenance: issue, task, or investigation links\n- Related specs: SPEC-001, ...\n- Superseded by: ADR-002 (when applicable)\n\n## Context\n\n## Decision\n\n## Alternatives considered\n\n## Consequences\n```\n\nOnly user/project governance accepts a specification or decision as normative. Agents may draft and link records, but must not silently promote them; acceptance is separate from implementation completion.\n\n## Task Format\n\n`- [Status] **[ID]** Title \\`Priority\\` \\`Complexity\\``\n\n| Status            | Priority      | Complexity |\n| ----------------- | ------------- | ---------- |\n| `[ ]` Todo        | `\uD83D\uDD34 Critical` | `S` Small  |\n| `[/]` In Progress | `\uD83D\uDFE0 High`     | `M` Medium |\n| `[x]` Done        | `\uD83D\uDD35 Medium`   | `L` Large  |\n| `[!]` Blocked     | `\u26AA Low`      | `XL` Huge  |\n\n## Metadata Rules\n\n- **Language:** English unless AGENT.md says otherwise.\n- **Tone:** Technical, concise, fact-based.\n- **Continuity:** Refer to previous work as \"we\" or \"the project\".\n";
 //#endregion
 //#region src/templates/tasks.d.ts
 /**
@@ -522,5 +530,5 @@ declare function resolveTargets(harnessIds: string[], cwd?: string): ResolvedTar
  */
 declare function getRawHarnessCodes(): HarnessCodes;
 //#endregion
-export { AGENT_FILE, AGENT_TEMPLATE, AUTONOMOS_DIR, AgentConfig, AgentContext, AgentParser, AgentSection, AncestorAgent, COMPLEXITIES, Complexity, Harness, HarnessCodes, HarnessCodesSchema, HarnessSchema, Installer, InstallerSchema, LOCAL_AGENT_TEMPLATE, MANIFEST_FILE, Manifest, ManifestSchema, PRIORITIES, PROTOCOL_FILE, PROTOCOL_TEMPLATE, PROTOCOL_TEMPLATE_V2026_1, PROTOCOL_VERSION, Priority, ResolvedTarget, TASKS_FILE, TASKS_TEMPLATE, Task, TaskParser, TaskStatus, WORKLOGS_DIR, createManifest, displayRelative, findAncestorAgents, findProjectRoot, generateAgentTemplate, generateLocalAgentTemplate, generateManifestContent, generateWorklogContent, getHarness, getRawHarnessCodes, isSamePath, listHarnesses, listPreferredHarnesses, mapTaskStatusToWorklogStatus, parseManifest, resolveTargets };
+export { AGENT_FILE, AGENT_TEMPLATE, AUTONOMOS_DIR, AgentConfig, AgentContext, AgentParser, AgentSection, AncestorAgent, COMPLEXITIES, Complexity, DECISIONS_DIR, Harness, HarnessCodes, HarnessCodesSchema, HarnessSchema, Installer, InstallerSchema, LOCAL_AGENT_TEMPLATE, MANIFEST_FILE, Manifest, ManifestSchema, PRIORITIES, PROTOCOL_FILE, PROTOCOL_TEMPLATE, PROTOCOL_TEMPLATE_V2026_1, PROTOCOL_VERSION, Priority, ResolvedTarget, SPECS_DIR, TASKS_FILE, TASKS_TEMPLATE, Task, TaskParser, TaskStatus, WORKLOGS_DIR, createManifest, displayRelative, findAncestorAgents, findProjectRoot, generateAgentTemplate, generateLocalAgentTemplate, generateManifestContent, generateWorklogContent, getHarness, getRawHarnessCodes, isSamePath, listHarnesses, listPreferredHarnesses, mapTaskStatusToWorklogStatus, parseManifest, resolveTargets };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/constants.ts","../src/schemas/harness-codes.ts","../src/schemas/manifest.ts","../src/types.ts","../src/templates/agent.ts","../src/templates/manifest.ts","../src/templates/protocol.ts","../src/templates/tasks.ts","../src/templates/worklog.ts","../src/parsers/agent-finder.ts","../src/parsers/agent-parser.ts","../src/parsers/project-root.ts","../src/parsers/task-parser.ts","../src/harness-codes.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/constants.ts","../src/schemas/harness-codes.ts","../src/schemas/manifest.ts","../src/types.ts","../src/templates/agent.ts","../src/templates/manifest.ts","../src/templates/protocol.ts","../src/templates/tasks.ts","../src/templates/worklog.ts","../src/parsers/agent-finder.ts","../src/parsers/agent-parser.ts","../src/parsers/project-root.ts","../src/parsers/task-parser.ts","../src/harness-codes.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import{z as e}from"zod";import{existsSync as t,statSync as n}from"node:fs";import{dirname as r,isAbsolute as i,join as a,relative as o,resolve as s,sep as c}from"node:path";import l from"js-yaml";const u=`0.3.1-alpha`,d=`.autonomos`,f=`manifest.json`,p=`PROTOCOL.md`,m=`TASKS.md`,h=`AGENT.md`,g=`worklogs`,_=e.object({workflowsDir:e.string().optional(),targetDir:e.string().optional(),skillsDir:e.string().optional(),commandsDir:e.string().optional(),globalTargetDir:e.string().optional(),fileExtension:e.string()}).refine(e=>!!e.workflowsDir||!!e.targetDir||!!e.skillsDir,{message:"At least one of `workflowsDir`, `targetDir`, or `skillsDir` must be defined"}),v=e.object({name:e.string().min(1),preferred:e.boolean(),installer:_}),y=e.object({platforms:e.record(e.string(),v)}),b=e.object({protocolVersion:e.string().describe(`Version of the Agent Protocol specification`),cliVersion:e.string().describe(`Version of the CLI that last updated this project`),initializedAt:e.string().datetime().describe(`ISO timestamp of project initialization`),lastUpdated:e.string().datetime().describe(`ISO timestamp of last protocol update`)}),x=[`🔴 Critical`,`🟠 High`,`🔵 Medium`,`⚪ Low`],S=[`S`,`M`,`L`,`XL`];function C(e=`Project`){return`---
+import{z as e}from"zod";import{existsSync as t,statSync as n}from"node:fs";import{dirname as r,isAbsolute as i,join as a,relative as o,resolve as s,sep as c}from"node:path";import l from"js-yaml";const u=`0.5.0-alpha`,d=`.autonomos`,f=`manifest.json`,p=`PROTOCOL.md`,m=`TASKS.md`,h=`AGENT.md`,ee=`worklogs`,g=`specs`,_=`decisions`,v=e.object({workflowsDir:e.string().optional(),targetDir:e.string().optional(),skillsDir:e.string().optional(),commandsDir:e.string().optional(),globalTargetDir:e.string().optional(),fileExtension:e.string()}).refine(e=>!!e.workflowsDir||!!e.targetDir||!!e.skillsDir,{message:"At least one of `workflowsDir`, `targetDir`, or `skillsDir` must be defined"}),y=e.object({name:e.string().min(1),preferred:e.boolean(),installer:v}),b=e.object({platforms:e.record(e.string(),y)}),x=e.object({protocolVersion:e.string().describe(`Version of the Agent Protocol specification`),cliVersion:e.string().describe(`Version of the CLI that last updated this project`),initializedAt:e.string().datetime().describe(`ISO timestamp of project initialization`),lastUpdated:e.string().datetime().describe(`ISO timestamp of last protocol update`)}),S=[`🔴 Critical`,`🟠 High`,`🔵 Medium`,`⚪ Low`],C=[`S`,`M`,`L`,`XL`];function w(e=`Project`){return`---
 name: "${e}"
 type: "project"
 status: "active"
@@ -29,61 +29,122 @@ status: "active"
 ## ⚠️ Known Constraints
 
 *List any technical debts, missing features, or external limitations.*
-`}function w(e){return`# AGENT: ${e}
+`}function T(e){return`# AGENT: ${e}
 
 - **Stack:** *(frameworks, libs specific to this module)*
 - **Conventions:** *(naming, exports, test patterns)*
 - **Constraints:** *(known issues, tech debt)*
-`}const T=C(),E=w(`module`);function D(e){let t=new Date().toISOString();return{protocolVersion:u,cliVersion:e,initializedAt:t,lastUpdated:t}}function O(e){return JSON.stringify(e,null,4)+`
-`}function k(e){let t=JSON.parse(e);return b.parse(t)}const A=`# AUTONOMOS PROTOCOL (v${u})
+`}const te=w(),E=T(`module`);function D(e){let t=new Date().toISOString();return{protocolVersion:u,cliVersion:e,initializedAt:t,lastUpdated:t}}function O(e){return JSON.stringify(e,null,4)+`
+`}function k(e){let t=JSON.parse(e);return x.parse(t)}const A=`# AUTONOMOS PROTOCOL (v${u})
 
 > This file defines the project's AI workflow contract. The workflows execute it. Do not duplicate workflow steps here.
 
 ## Quick Reference
 
-| Action | How |
-|---|---|
-| Start a session | Read the \`/session\` workflow |
-| Start a task | Read the \`/task\` workflow |
-| End a session | Read the \`/crystallize\` workflow |
-| Get context | Read \`AGENT.md\` (root → local) |
-| Find all AGENT.md | \`find . -name AGENT.md -not -path '*/node_modules/*'\` |
-| Pick next task | Open \`.autonomos/TASKS.md\`, pick highest priority not \`[x]\` |
-| Log session work | Create \`.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md\` |
+| Action                           | How                                                                                |
+| -------------------------------- | ---------------------------------------------------------------------------------- |
+| Start a session                  | Read the \`/session\` workflow                                                       |
+| Start a task                     | Read the \`/task\` workflow                                                          |
+| Triage a problem or proposal     | Read the optional \`/issue\` workflow                                                |
+| Adopt existing project knowledge | Read the optional \`/adopt\` workflow                                                |
+| Audit accumulated drift          | Read the \`/reconcile\` workflow                                                     |
+| End a session                    | Read the \`/crystallize\` workflow                                                   |
+| Get context                      | Read root \`AGENT.md\`, then only the selected scope's ancestor chain                |
+| Resolve objective                | Explicit user request first; otherwise resume \`[/]\` or pick highest-priority \`[ ]\` |
+| Log session work                 | Create \`.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md\`                               |
 
 ## File Map
 
-| File | Location | Role |
-|---|---|---|
-| \`AGENT.md\` | Root + any subdirectory | Fractal knowledge base (context, preferences, stack) |
-| \`TASKS.md\` | \`.autonomos/TASKS.md\` | Single source of truth for task state |
-| \`worklogs/\` | \`.autonomos/worklogs/\` | Session history (one file per session) |
-| \`PROTOCOL.md\` | \`.autonomos/PROTOCOL.md\` | This file — read-only reference |
-| \`manifest.json\` | \`.autonomos/manifest.json\` | Protocol version metadata |
+| File            | Location                   | Role                                              |
+| --------------- | -------------------------- | ------------------------------------------------- |
+| \`AGENT.md\`      | Root + any subdirectory    | Durable guidance for its directory scope          |
+| \`TASKS.md\`      | \`.autonomos/TASKS.md\`      | Single source of truth for task state             |
+| \`ISSUES.md\`     | \`.autonomos/ISSUES.md\`     | Optional problem, proposal, and question intake   |
+| \`worklogs/\`     | \`.autonomos/worklogs/\`     | Historical session evidence, not current guidance |
+| \`specs/\`        | \`.autonomos/specs/\`        | Optional project-owned normative target state     |
+| \`decisions/\`    | \`.autonomos/decisions/\`    | Optional project-owned decision records (ADRs)    |
+| \`PROTOCOL.md\`   | \`.autonomos/PROTOCOL.md\`   | This file — read-only reference                   |
+| \`manifest.json\` | \`.autonomos/manifest.json\` | Protocol version metadata                         |
 
 ## AGENT.md Format Rules
 
+Store only stable guidance that will affect different future tasks. Keep transient evidence in worklogs and operational explanations in component documentation. Use the narrowest applicable \`AGENT.md\`; consolidate or replace obsolete entries instead of appending history.
+
 **Root \`AGENT.md\`** — Must use the structured template (frontmatter + sections: Context, Workflow, Stack, Key Directories, Constraints).
 
 **Local \`AGENT.md\`** (in any subdirectory) — Free format. One line is enough if it is clear. What matters: the next session can use it. Example:
 
 \`\`\`markdown
 # AGENT: packages/core
+
 - Stack: TypeScript, Vitest, tsdown
-- Conventions: exports via src/index.ts, tests co-located (*.test.ts)
+- Conventions: exports via src/index.ts, tests co-located (\\*.test.ts)
 - Constraint: template changes require workflow test updates
 \`\`\`
 
+## Issue, Specification, Decision, and Task Rules
+
+Issues describe evidence, impact, and a desired outcome without choosing implementation; proposed directions remain hypotheses until an approach is accepted. Specifications describe accepted target behavior or requirements that may guide multiple tasks. A decision record (commonly ADR, Architecture Decision Record) captures one technical choice and its rationale. Tasks describe an accepted intervention and completion criteria. Use optional \`ISSUES.md\`, \`specs/\`, and \`decisions/\` only when they provide value; direct, clear changes may become tasks immediately. Link related issues, specs, decisions, and tasks in both directions.
+
+## Specification and Decision Rules
+
+- \`.autonomos/specs/\` and \`.autonomos/decisions/\` are optional, project-owned, first-use directories; \`init\`, \`update\`, and artifact-integrity checks do not create or overwrite them.
+- Keep one Markdown file per bounded specification or decision. Include status, scope, provenance, acceptance criteria or consequences, and replacement links where relevant; no parser or independent version is required initially.
+- Specification status is \`draft\`, \`accepted\`, or \`superseded\`. Only \`accepted\` is normative; \`superseded\` points to its successor. Acceptance does not mean implementation is complete.
+- Decision records use \`proposed\`, \`accepted\`, or \`superseded\`; they preserve rationale and alternatives rather than duplicating the full specification.
+- Keep stable agent operating rules in \`AGENT.md\`, user/developer reference in \`docs/\`, execution state in \`TASKS.md\`, and historical evidence in \`worklogs/\`.
+- Read only relevant accepted records at task start. Use \`/adopt\` to extract legacy knowledge; never rewrite historical worklogs, issues, or tasks to create current artifacts.
+
+The protocol-facing name is **decision record**. **ADR** (Architecture Decision Record) is a common convention for the same kind of document, not a required external standard. Use these lightweight Markdown shapes as a starting point; they are conventions, not parser-enforced schemas:
+
+\`\`\`markdown
+# SPEC-001 — Concise target-state title
+
+- Status: draft | accepted | superseded
+- Scope: component, capability, or boundary
+- Provenance: issue, discussion, or source links
+- Related decisions: ADR-001, ...
+- Superseded by: SPEC-002 (when applicable)
+
+## Intent
+
+## Requirements
+
+## Acceptance criteria
+
+## Out of scope
+\`\`\`
+
+\`\`\`markdown
+# ADR-001 — Concise decision title
+
+- Status: proposed | accepted | superseded
+- Scope: component or technical boundary
+- Provenance: issue, task, or investigation links
+- Related specs: SPEC-001, ...
+- Superseded by: ADR-002 (when applicable)
+
+## Context
+
+## Decision
+
+## Alternatives considered
+
+## Consequences
+\`\`\`
+
+Only user/project governance accepts a specification or decision as normative. Agents may draft and link records, but must not silently promote them; acceptance is separate from implementation completion.
+
 ## Task Format
 
 \`- [Status] **[ID]** Title \\\`Priority\\\` \\\`Complexity\\\`\`
 
-| Status | Priority | Complexity |
-|---|---|---|
-| \`[ ]\` Todo | \`🔴 Critical\` | \`S\` Small |
-| \`[/]\` In Progress | \`🟠 High\` | \`M\` Medium |
-| \`[x]\` Done | \`🔵 Medium\` | \`L\` Large |
-| \`[!]\` Blocked | \`⚪ Low\` | \`XL\` Huge |
+| Status            | Priority      | Complexity |
+| ----------------- | ------------- | ---------- |
+| \`[ ]\` Todo        | \`🔴 Critical\` | \`S\` Small  |
+| \`[/]\` In Progress | \`🟠 High\`     | \`M\` Medium |
+| \`[x]\` Done        | \`🔵 Medium\`   | \`L\` Large  |
+| \`[!]\` Blocked     | \`⚪ Low\`      | \`XL\` Huge  |
 
 ## Metadata Rules
 
@@ -127,5 +188,5 @@ ${e.nextSteps.map(e=>`- ${e}`).join(`
 `)}
 `}function P(e){switch(e){case`DONE`:return`Complete`;case`BLOCKED`:return`Blocked`;default:return`Partial`}}function F(e,n=process.cwd()){let c=s(n),l=I(e,c),u=o(c,l);if(u.startsWith(`..`)||i(u))throw Error(`Target "${e}" is outside the project root "${c}". findAncestorAgents only handles paths within the project.`);let d=L(z(l)?l:r(l),c),f=[];for(let e of d){let n=a(e,h);t(n)&&f.push({dir:e,path:n,relativeDir:R(e,c)})}return f}function I(e,t){return i(e)?e:a(t,e)}function L(e,t){let n=o(t,e);if(n===``||n===`.`)return[t];let r=n.split(c).filter(e=>e!==``&&e!==`.`),i=[t],s=t;for(let e of r)s=a(s,e),i.push(s);return i}function R(e,t){let n=o(t,e);return n===``?`.`:n}function z(e){try{return n(e).isDirectory()}catch{return!1}}var B=class{static parse(e){let t=e,n={},r=e.match(/^---\r?\n([\s\S]*?)\r?\n---/);if(r)try{n=l.load(r[1]),t=e.slice(r[0].length).trim()}catch(e){console.error(`Failed to parse Agent frontmatter:`,e)}let i=t.split(/\r?\n/),a=[],o=n.name??`Unknown Agent`,s=null,c=[];for(let e of i){if(e.startsWith(`# `)&&!n.name){let t=e.replace(`# `,``).trim();o=t.toUpperCase().startsWith(`AGENT CONTEXT:`)?t.slice(14).replace(/^[:\s-]+/,``).trim():t;continue}if(e.startsWith(`## `)){s&&(s.content=c.join(`
 `).trim(),a.push(s)),s={title:e.replace(`## `,``).trim(),content:``},c=[];continue}s&&c.push(e)}return s&&(s.content=c.join(`
-`).trim(),a.push(s)),{title:o,sections:a,metadata:n}}};const V=[d,`.git`];function H(e){if(!e)return null;let n=s(e);for(;;){if(V.some(e=>t(a(n,e))))return n;let e=r(n);if(e===n)return null;n=e}}function U(e,t){return!e||!t?!1:s(e)===s(t)}function W(e,t){let n=o(t,e);return n===``||n===`.`?`.`:n.startsWith(`..${c}`)||n===`..`||i(n)?s(e):n}var G=class{static parse(e){let t=[],n=e.split(/\r?\n/),r=/- \[([ x/!])\] \*\*\[(.+)\]\*\* (.+) `Priority: (.+)` `Complexity: (.+)`/;for(let e of n){let n=e.match(r);if(n){let[,e=` `,r=``,i=``,a=``,o=``]=n;t.push({id:r,title:i.trim(),priority:a,complexity:o,status:this.mapStatus(e)})}}return t}static mapStatus(e){switch(e){case` `:return`TODO`;case`/`:return`IN_PROGRESS`;case`x`:return`DONE`;case`!`:return`BLOCKED`;default:return`TODO`}}};const K=y.parse({$schema:`./harness-codes.schema.json`,_comment:"Autonomos harness codes. Each entry tells `autonomos init` where to write the protocol workflow files. The shape is intentionally minimal: only what the installer needs. To add a new harness, add an entry here. To remove one, delete it. The schema is enforced at load time by Zod (see schemas/harness-codes.ts).",platforms:{cline:{name:`Cline`,preferred:!0,installer:{workflowsDir:`.clinerules/workflows`,fileExtension:`.md`,_note:"In Cline, a single .md file in .clinerules/workflows/ acts as both a workflow (auto-discovered via the frontmatter `description` field) and a slash command (invoked via /<name>)."}},"claude-code":{name:`Claude Code`,preferred:!0,installer:{workflowsDir:`.claude/skills`,commandsDir:`.claude/commands`,fileExtension:`.md`}},codex:{name:`Codex`,preferred:!0,installer:{workflowsDir:`.agents/skills`,fileExtension:`.md`,globalTargetDir:`~/.codex/skills`,_note:`OpenAI Codex. Uses the cross-tool .agents/skills/ standard.`}},antigravity:{name:`Antigravity`,preferred:!0,installer:{workflowsDir:`.agent/workflows`,fileExtension:`.md`,globalTargetDir:`~/.gemini/antigravity/skills`,_note:"Google Antigravity. Uses `.agent/workflows/` (not `.agent/skills/`). Singular `.agent/` (NOT the cross-tool `.agents/` standard). Cannot be deduplicated with the others."}},opencode:{name:`OpenCode`,preferred:!0,installer:{workflowsDir:`.agents/skills`,commandsDir:`.opencode/commands`,fileExtension:`.md`}},kilocode:{name:`KiloCode`,preferred:!0,installer:{workflowsDir:`.agents/skills`,fileExtension:`.md`,globalTargetDir:`~/.kilocode/skills`}}}});function q(e){let t=K.platforms[e];if(!t){let t=Object.keys(K.platforms).join(`, `);throw Error(`Unknown harness: "${e}". Known harnesses: ${t}`)}return t}function J(){return Object.entries(K.platforms).map(([e,t])=>({id:e,harness:t}))}function Y(){return J().filter(({harness:e})=>e.preferred)}function X(e,t=`.`){let n=new Map;for(let r of e){let{installer:e}=q(r);Z(n,e,r,t)}return Array.from(n.values())}function Z(e,t,n,r){let i=t.fileExtension;t.workflowsDir?Q(e,$(r,t.workflowsDir),i,n):t.targetDir?Q(e,$(r,t.targetDir),i,n):t.skillsDir&&Q(e,$(r,t.skillsDir),i,n),t.commandsDir&&Q(e,$(r,t.commandsDir),i,n)}function Q(e,t,n,r){let i=e.get(t);i?i.usedBy.includes(r)||i.usedBy.push(r):e.set(t,{path:t,fileExtension:n,usedBy:[r]})}function $(e,t){return e===`.`||e===``?t:t.startsWith(`/`)?`${e}${t}`:`${e}/${t}`}function ee(){return K}export{h as AGENT_FILE,T as AGENT_TEMPLATE,d as AUTONOMOS_DIR,B as AgentParser,S as COMPLEXITIES,y as HarnessCodesSchema,v as HarnessSchema,_ as InstallerSchema,E as LOCAL_AGENT_TEMPLATE,f as MANIFEST_FILE,b as ManifestSchema,x as PRIORITIES,p as PROTOCOL_FILE,A as PROTOCOL_TEMPLATE,j as PROTOCOL_TEMPLATE_V2026_1,u as PROTOCOL_VERSION,m as TASKS_FILE,M as TASKS_TEMPLATE,G as TaskParser,g as WORKLOGS_DIR,D as createManifest,W as displayRelative,F as findAncestorAgents,H as findProjectRoot,C as generateAgentTemplate,w as generateLocalAgentTemplate,O as generateManifestContent,N as generateWorklogContent,q as getHarness,ee as getRawHarnessCodes,U as isSamePath,J as listHarnesses,Y as listPreferredHarnesses,P as mapTaskStatusToWorklogStatus,k as parseManifest,X as resolveTargets};
+`).trim(),a.push(s)),{title:o,sections:a,metadata:n}}};const V=[d,`.git`];function H(e){if(!e)return null;let n=s(e);for(;;){if(V.some(e=>t(a(n,e))))return n;let e=r(n);if(e===n)return null;n=e}}function U(e,t){return!e||!t?!1:s(e)===s(t)}function W(e,t){let n=o(t,e);return n===``||n===`.`?`.`:n.startsWith(`..${c}`)||n===`..`||i(n)?s(e):n}var G=class{static parse(e){let t=[],n=e.split(/\r?\n/),r=/- \[([ x/!])\] \*\*\[(.+)\]\*\* (.+) `Priority: (.+)` `Complexity: (.+)`/;for(let e of n){let n=e.match(r);if(n){let[,e=` `,r=``,i=``,a=``,o=``]=n;t.push({id:r,title:i.trim(),priority:a,complexity:o,status:this.mapStatus(e)})}}return t}static mapStatus(e){switch(e){case` `:return`TODO`;case`/`:return`IN_PROGRESS`;case`x`:return`DONE`;case`!`:return`BLOCKED`;default:return`TODO`}}};const K=b.parse({$schema:`./harness-codes.schema.json`,_comment:"Autonomos harness codes. Each entry tells `autonomos init` where to write the protocol workflow files. The shape is intentionally minimal: only what the installer needs. To add a new harness, add an entry here. To remove one, delete it. The schema is enforced at load time by Zod (see schemas/harness-codes.ts).",platforms:{cline:{name:`Cline`,preferred:!0,installer:{workflowsDir:`.clinerules/workflows`,fileExtension:`.md`,_note:"In Cline, a single .md file in .clinerules/workflows/ acts as both a workflow (auto-discovered via the frontmatter `description` field) and a slash command (invoked via /<name>)."}},"claude-code":{name:`Claude Code`,preferred:!0,installer:{workflowsDir:`.claude/skills`,commandsDir:`.claude/commands`,fileExtension:`.md`}},codex:{name:`Codex`,preferred:!0,installer:{workflowsDir:`.agents/skills`,fileExtension:`.md`,globalTargetDir:`~/.codex/skills`,_note:`OpenAI Codex. Uses the cross-tool .agents/skills/ standard.`}},antigravity:{name:`Antigravity`,preferred:!0,installer:{workflowsDir:`.agent/workflows`,fileExtension:`.md`,globalTargetDir:`~/.gemini/antigravity/skills`,_note:"Google Antigravity. Uses `.agent/workflows/` (not `.agent/skills/`). Singular `.agent/` (NOT the cross-tool `.agents/` standard). Cannot be deduplicated with the others."}},opencode:{name:`OpenCode`,preferred:!0,installer:{workflowsDir:`.agents/skills`,commandsDir:`.opencode/commands`,fileExtension:`.md`}},kilocode:{name:`KiloCode`,preferred:!0,installer:{workflowsDir:`.agents/skills`,fileExtension:`.md`,globalTargetDir:`~/.kilocode/skills`}}}});function q(e){let t=K.platforms[e];if(!t){let t=Object.keys(K.platforms).join(`, `);throw Error(`Unknown harness: "${e}". Known harnesses: ${t}`)}return t}function J(){return Object.entries(K.platforms).map(([e,t])=>({id:e,harness:t}))}function Y(){return J().filter(({harness:e})=>e.preferred)}function X(e,t=`.`){let n=new Map;for(let r of e){let{installer:e}=q(r);Z(n,e,r,t)}return Array.from(n.values())}function Z(e,t,n,r){let i=t.fileExtension;t.workflowsDir?Q(e,$(r,t.workflowsDir),i,n):t.targetDir?Q(e,$(r,t.targetDir),i,n):t.skillsDir&&Q(e,$(r,t.skillsDir),i,n),t.commandsDir&&Q(e,$(r,t.commandsDir),i,n)}function Q(e,t,n,r){let i=e.get(t);i?i.usedBy.includes(r)||i.usedBy.push(r):e.set(t,{path:t,fileExtension:n,usedBy:[r]})}function $(e,t){return e===`.`||e===``?t:t.startsWith(`/`)?`${e}${t}`:`${e}/${t}`}function ne(){return K}export{h as AGENT_FILE,te as AGENT_TEMPLATE,d as AUTONOMOS_DIR,B as AgentParser,C as COMPLEXITIES,_ as DECISIONS_DIR,b as HarnessCodesSchema,y as HarnessSchema,v as InstallerSchema,E as LOCAL_AGENT_TEMPLATE,f as MANIFEST_FILE,x as ManifestSchema,S as PRIORITIES,p as PROTOCOL_FILE,A as PROTOCOL_TEMPLATE,j as PROTOCOL_TEMPLATE_V2026_1,u as PROTOCOL_VERSION,g as SPECS_DIR,m as TASKS_FILE,M as TASKS_TEMPLATE,G as TaskParser,ee as WORKLOGS_DIR,D as createManifest,W as displayRelative,F as findAncestorAgents,H as findProjectRoot,w as generateAgentTemplate,T as generateLocalAgentTemplate,O as generateManifestContent,N as generateWorklogContent,q as getHarness,ne as getRawHarnessCodes,U as isSamePath,J as listHarnesses,Y as listPreferredHarnesses,P as mapTaskStatusToWorklogStatus,k as parseManifest,X as resolveTargets};
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["harnessCodesData"],"sources":["../src/constants.ts","../src/schemas/harness-codes.ts","../src/schemas/manifest.ts","../src/types.ts","../src/templates/agent.ts","../src/templates/manifest.ts","../src/templates/protocol.ts","../src/templates/tasks.ts","../src/templates/worklog.ts","../src/parsers/agent-finder.ts","../src/parsers/agent-parser.ts","../src/parsers/project-root.ts","../src/parsers/task-parser.ts","../src/data/harness-codes.json","../src/harness-codes.ts"],"sourcesContent":["/**\n * Agent Protocol Specification Version (Independent of Package versions)\n * This refers to the schema and behavioral contract version.\n */\nexport const PROTOCOL_VERSION = '0.3.1-alpha'\n\n/**\n * Directory name for Autonomos configuration\n */\nexport const AUTONOMOS_DIR = '.autonomos'\n\n/**\n * Manifest filename\n */\nexport const MANIFEST_FILE = 'manifest.json'\n\n/**\n * Protocol filename\n */\nexport const PROTOCOL_FILE = 'PROTOCOL.md'\n\n/**\n * Tasks filename\n */\nexport const TASKS_FILE = 'TASKS.md'\n\n/**\n * Agent context filename (at project root)\n */\nexport const AGENT_FILE = 'AGENT.md'\n\n/**\n * Worklogs directory name\n */\nexport const WORKLOGS_DIR = 'worklogs'\n","import { z } from 'zod'\n\n/**\n * Installer configuration for a single harness.\n *\n * At least one of `workflowsDir`, `targetDir`, or `skillsDir` must be defined.\n *\n * - `workflowsDir`: Where session.md, task.md, crystallize.md are written.\n *    Preferred field — used by most harnesses.\n * - `targetDir`: Single directory (legacy, like Cline's .clinerules/workflows/).\n * - `skillsDir`: Skills directory (legacy, for harnesses that don't distinguish\n *    skills from workflows).\n * - `commandsDir`: Additional commands directory (optional).\n */\nexport const InstallerSchema = z\n    .object({\n        workflowsDir: z.string().optional(),\n        targetDir: z.string().optional(),\n        skillsDir: z.string().optional(),\n        commandsDir: z.string().optional(),\n        globalTargetDir: z.string().optional(),\n        fileExtension: z.string(),\n    })\n    .refine(\n        data => Boolean(data.workflowsDir) || Boolean(data.targetDir) || Boolean(data.skillsDir),\n        {\n            message: 'At least one of `workflowsDir`, `targetDir`, or `skillsDir` must be defined',\n        }\n    )\n\n/**\n * A single harness entry.\n */\nexport const HarnessSchema = z.object({\n    name: z.string().min(1),\n    preferred: z.boolean(),\n    installer: InstallerSchema,\n})\n\n/**\n * Root schema for the harness-codes configuration file.\n */\nexport const HarnessCodesSchema = z.object({\n    platforms: z.record(z.string(), HarnessSchema),\n})\n\nexport type Installer = z.infer<typeof InstallerSchema>\nexport type Harness = z.infer<typeof HarnessSchema>\nexport type HarnessCodes = z.infer<typeof HarnessCodesSchema>\n","import { z } from 'zod'\n\n/**\n * Manifest Schema for .autonomos/manifest.json\n */\nexport const ManifestSchema = z.object({\n    protocolVersion: z.string().describe('Version of the Agent Protocol specification'),\n    cliVersion: z.string().describe('Version of the CLI that last updated this project'),\n    initializedAt: z.string().datetime().describe('ISO timestamp of project initialization'),\n    lastUpdated: z.string().datetime().describe('ISO timestamp of last protocol update'),\n})\n\nexport type Manifest = z.infer<typeof ManifestSchema>\n","/**\n * Priority levels for tasks\n */\nexport type Priority = '🔴 Critical' | '🟠 High' | '🔵 Medium' | '⚪ Low'\n\n/**\n * Complexity estimates for tasks\n */\nexport type Complexity = 'S' | 'M' | 'L' | 'XL'\n\n/**\n * Task status markers\n */\nexport type TaskStatus = 'TODO' | 'IN_PROGRESS' | 'DONE' | 'BLOCKED'\n\n/**\n * Task entity parsed from TASKS.md\n */\nexport interface Task {\n    id: string\n    title: string\n    priority: Priority\n    complexity: Complexity\n    status: TaskStatus\n    worklogPath?: string\n}\n\n/**\n * Agent configuration parsed from AGENT.md\n */\nexport interface AgentConfig {\n    name: string\n    description?: string\n    stack: string[]\n    preferences?: Record<string, any>\n}\n\nexport interface AgentSection {\n    title: string\n    content: string\n}\n\nexport interface AgentContext {\n    title: string\n    description?: string\n    sections: AgentSection[]\n    metadata?: Record<string, any>\n}\n\nexport const PRIORITIES: Priority[] = ['🔴 Critical', '🟠 High', '🔵 Medium', '⚪ Low']\nexport const COMPLEXITIES: Complexity[] = ['S', 'M', 'L', 'XL']\n","/**\n * Template for AGENT.md - The context anchor at project root\n * @param projectName - Name of the project to personalize the template\n */\nexport function generateAgentTemplate(projectName: string = 'Project'): string {\n    return `---\nname: \"${projectName}\"\ntype: \"project\"\nstatus: \"active\"\n---\n# AGENT CONTEXT: ${projectName}\n\n## 🧠 Context & Objectives\n\n*Describe what this project does and its main goals.*\n\n## ⚙️ Workflow & Preferences\n\n- **Commits:** Conventional Commits\n- **Language:** English\n\n## 🏗 Stack & Architecture\n\n- **Tech:** *(List frameworks, libraries)*\n- **Patterns:** *(Architecture patterns used)*\n\n## 📁 Key Directories\n\n| Path | Description |\n|------|-------------|\n| \\`src/\\` | Source code |\n| \\`.autonomos/\\` | Agent Protocol files |\n\n## ⚠️ Known Constraints\n\n*List any technical debts, missing features, or external limitations.*\n`\n}\n\n/**\n * Generate a minimal local AGENT.md for subdirectories.\n * Free format by design — low friction encourages creation.\n * @param dirName - Name of the directory\n */\nexport function generateLocalAgentTemplate(dirName: string): string {\n    return `# AGENT: ${dirName}\n\n- **Stack:** *(frameworks, libs specific to this module)*\n- **Conventions:** *(naming, exports, test patterns)*\n- **Constraints:** *(known issues, tech debt)*\n`\n}\n\n/**\n * Default root AGENT.md template\n */\nexport const AGENT_TEMPLATE = generateAgentTemplate()\n\n/**\n * Default local AGENT.md template\n */\nexport const LOCAL_AGENT_TEMPLATE = generateLocalAgentTemplate('module')\n","import { PROTOCOL_VERSION } from '../constants'\nimport { ManifestSchema, type Manifest } from '../schemas/manifest'\n\n/**\n * Creates a new manifest object with current timestamps\n */\nexport function createManifest(cliVersion: string): Manifest {\n    const now = new Date().toISOString()\n    return {\n        protocolVersion: PROTOCOL_VERSION,\n        cliVersion,\n        initializedAt: now,\n        lastUpdated: now,\n    }\n}\n\n/**\n * Generates the manifest.json content as a formatted string\n */\nexport function generateManifestContent(manifest: Manifest): string {\n    return JSON.stringify(manifest, null, 4) + '\\n'\n}\n\n/**\n * Parses manifest.json content into a Manifest object with validation\n */\nexport function parseManifest(content: string): Manifest {\n    const data = JSON.parse(content)\n    return ManifestSchema.parse(data)\n}\n","import { PROTOCOL_VERSION } from '../constants'\n\n/**\n * The Protocol kernel template — v0.3\n *\n * Design principles (v0.3):\n * - PROTOCOL.md is a compact REFERENCE, not an executable workflow.\n * - All step-by-step instructions live in the 3 workflow files.\n * - No duplication between PROTOCOL.md and workflows.\n * - Short enough that an LLM can re-scan it mid-session without cost.\n */\nexport const PROTOCOL_TEMPLATE = `# AUTONOMOS PROTOCOL (v${PROTOCOL_VERSION})\n\n> This file defines the project's AI workflow contract. The workflows execute it. Do not duplicate workflow steps here.\n\n## Quick Reference\n\n| Action | How |\n|---|---|\n| Start a session | Read the \\`/session\\` workflow |\n| Start a task | Read the \\`/task\\` workflow |\n| End a session | Read the \\`/crystallize\\` workflow |\n| Get context | Read \\`AGENT.md\\` (root → local) |\n| Find all AGENT.md | \\`find . -name AGENT.md -not -path '*/node_modules/*'\\` |\n| Pick next task | Open \\`.autonomos/TASKS.md\\`, pick highest priority not \\`[x]\\` |\n| Log session work | Create \\`.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md\\` |\n\n## File Map\n\n| File | Location | Role |\n|---|---|---|\n| \\`AGENT.md\\` | Root + any subdirectory | Fractal knowledge base (context, preferences, stack) |\n| \\`TASKS.md\\` | \\`.autonomos/TASKS.md\\` | Single source of truth for task state |\n| \\`worklogs/\\` | \\`.autonomos/worklogs/\\` | Session history (one file per session) |\n| \\`PROTOCOL.md\\` | \\`.autonomos/PROTOCOL.md\\` | This file — read-only reference |\n| \\`manifest.json\\` | \\`.autonomos/manifest.json\\` | Protocol version metadata |\n\n## AGENT.md Format Rules\n\n**Root \\`AGENT.md\\`** — Must use the structured template (frontmatter + sections: Context, Workflow, Stack, Key Directories, Constraints).\n\n**Local \\`AGENT.md\\`** (in any subdirectory) — Free format. One line is enough if it is clear. What matters: the next session can use it. Example:\n\n\\`\\`\\`markdown\n# AGENT: packages/core\n- Stack: TypeScript, Vitest, tsdown\n- Conventions: exports via src/index.ts, tests co-located (*.test.ts)\n- Constraint: template changes require workflow test updates\n\\`\\`\\`\n\n## Task Format\n\n\\`- [Status] **[ID]** Title \\\\\\`Priority\\\\\\` \\\\\\`Complexity\\\\\\`\\`\n\n| Status | Priority | Complexity |\n|---|---|---|\n| \\`[ ]\\` Todo | \\`🔴 Critical\\` | \\`S\\` Small |\n| \\`[/]\\` In Progress | \\`🟠 High\\` | \\`M\\` Medium |\n| \\`[x]\\` Done | \\`🔵 Medium\\` | \\`L\\` Large |\n| \\`[!]\\` Blocked | \\`⚪ Low\\` | \\`XL\\` Huge |\n\n## Metadata Rules\n\n- **Language:** English unless AGENT.md says otherwise.\n- **Tone:** Technical, concise, fact-based.\n- **Continuity:** Refer to previous work as \"we\" or \"the project\".\n`\n\n/**\n * @deprecated Use PROTOCOL_TEMPLATE instead\n */\nexport const PROTOCOL_TEMPLATE_V2026_1 = PROTOCOL_TEMPLATE\n","/**\n * Template for TASKS.md - The task registry\n */\nexport const TASKS_TEMPLATE = `# PROJECT TASKS & ROADMAP\n\n> **LEGEND**\n> **Priority:** [🔴 Critical] [🟠 High] [🔵 Medium] [⚪ Low]\n> **Complexity:** [S] Small (1h), [M] Medium (4h), [L] Large (1-2 days), [XL] Huge (Planning req.)\n> **Status:** [ ] Todo, [/] In Progress, [x] Done, [!] Blocked\n\n## 🚀 Active Sprint\n\n- [ ] **[INIT-01]** Review project context and structure \\`Priority: 🔵\\` \\`Complexity: S\\`\n\n## 🔮 Backlog\n\n*(Add future tasks here)*\n`\n","import type { TaskStatus } from '../types'\n\ninterface WorklogOptions {\n    taskId: string\n    taskName: string\n    date?: string\n    status: 'Complete' | 'Partial' | 'Blocked'\n    description: string\n    filesModified: string[]\n    decisions: string[]\n    challenges: string[]\n    nextSteps: string[]\n}\n\n/**\n * Generate a Worklog markdown content\n */\nexport function generateWorklogContent(options: WorklogOptions): string {\n    const date = options.date ?? new Date().toISOString().split('T')[0]\n\n    return `# WORKLOG: [${options.taskId}] ${options.taskName}\n**Date:** ${date}\n**Agent Status:** [${options.status}]\n\n## 📝 Description\n${options.description}\n\n## 🛠 Technical Details\n- **Files Modified:**\n${options.filesModified.map(f => `  - ${f}`).join('\\n')}\n- **Key Decisions:**\n${options.decisions.map(d => `  - ${d}`).join('\\n')}\n- **Challenges:**\n${options.challenges.map(c => `  - ${c}`).join('\\n')}\n\n## ⏭ Next Steps / Context for Successor\n${options.nextSteps.map(s => `- ${s}`).join('\\n')}\n`\n}\n\n/**\n * Common status mapping for worklogs\n */\nexport function mapTaskStatusToWorklogStatus(\n    status: TaskStatus\n): 'Complete' | 'Partial' | 'Blocked' {\n    switch (status) {\n        case 'DONE':\n            return 'Complete'\n        case 'BLOCKED':\n            return 'Blocked'\n        default:\n            return 'Partial'\n    }\n}\n","import { existsSync, statSync } from 'node:fs'\nimport { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'\n\nimport { AGENT_FILE } from '../constants'\n\n/**\n * Result of an ancestor lookup: a single AGENT.md entry that exists on the\n * path between a target file or directory and the project root.\n */\nexport interface AncestorAgent {\n    /** Absolute path to the directory containing the AGENT.md */\n    dir: string\n    /** Absolute path to the AGENT.md file */\n    path: string\n    /** Path of the directory relative to the project root */\n    relativeDir: string\n}\n\n/**\n * Return the ordered list of AGENT.md files that exist on the path from a\n * target file or directory up to the project root. The order is root-first,\n * then each intermediate directory, then the target directory itself.\n *\n * Non-existent AGENT.md files are silently skipped (the chain can have gaps).\n *\n * @param target - The absolute or project-relative path to a file or directory.\n * @param projectRoot - The absolute path of the project root (where the root\n *   AGENT.md lives). Defaults to the current working directory.\n *\n * @example\n *   findAncestorAgents('/proj/apps/web/components/ui/button.tsx', '/proj')\n *   // Returns, in order:\n *   // - { dir: '/proj',                path: '/proj/AGENT.md' }\n *   // - { dir: '/proj/apps/web',       path: '/proj/apps/web/AGENT.md' }\n *   // (apps/, components/ skipped because they have no AGENT.md)\n *   // (button.tsx itself is a file, so its parent dir is the last one checked)\n */\nexport function findAncestorAgents(\n    target: string,\n    projectRoot: string = process.cwd()\n): AncestorAgent[] {\n    const absRoot = resolve(projectRoot)\n    const absTarget = resolveAgainstRoot(target, absRoot)\n\n    // Validate that the target lives within the project root\n    const relToRoot = relative(absRoot, absTarget)\n    if (relToRoot.startsWith('..') || isAbsolute(relToRoot)) {\n        throw new Error(\n            `Target \"${target}\" is outside the project root \"${absRoot}\". ` +\n                `findAncestorAgents only handles paths within the project.`\n        )\n    }\n\n    // Collect every directory from the target up to the root, in root-first order.\n    // For a file target, we only look at the directory chain (not the file itself).\n    // For a directory target, the directory itself is included as the last entry.\n    const targetDir = isDirectory(absTarget) ? absTarget : dirname(absTarget)\n    const dirs = collectAncestorDirs(targetDir, absRoot)\n\n    const result: AncestorAgent[] = []\n    for (const dir of dirs) {\n        const agentPath = join(dir, AGENT_FILE)\n        if (existsSync(agentPath)) {\n            result.push({\n                dir,\n                path: agentPath,\n                relativeDir: relativeDir(dir, absRoot),\n            })\n        }\n    }\n\n    return result\n}\n\n/**\n * Resolve a target path against the project root. Accepts absolute paths\n * (returned as-is) and project-relative paths (joined with the root).\n */\nfunction resolveAgainstRoot(target: string, absRoot: string): string {\n    if (isAbsolute(target)) return target\n    return join(absRoot, target)\n}\n\n/**\n * Return the directory chain from a starting directory up to (and including)\n * the project root, in root-first order. The chain is computed by walking\n * the relative path segments from the starting dir back to the root.\n */\nfunction collectAncestorDirs(startDir: string, absRoot: string): string[] {\n    const rel = relative(absRoot, startDir)\n    if (rel === '' || rel === '.') {\n        return [absRoot]\n    }\n\n    const segments = rel.split(sep).filter(s => s !== '' && s !== '.')\n    const chain: string[] = [absRoot]\n    let acc = absRoot\n    for (const seg of segments) {\n        acc = join(acc, seg)\n        chain.push(acc)\n    }\n    return chain\n}\n\n/**\n * Compute the directory's path relative to the project root, in a form\n * suitable for display. The root itself is rendered as \".\".\n */\nfunction relativeDir(dir: string, absRoot: string): string {\n    const rel = relative(absRoot, dir)\n    return rel === '' ? '.' : rel\n}\n\nfunction isDirectory(p: string): boolean {\n    try {\n        return statSync(p).isDirectory()\n    } catch {\n        return false\n    }\n}\n","import yaml from 'js-yaml'\nimport type { AgentContext, AgentSection } from '../types'\n\nexport class AgentParser {\n    /**\n     * Parse an AGENT.md content into a structured AgentContext\n     */\n    static parse(markdown: string): AgentContext {\n        let content = markdown\n        let metadata: Record<string, any> = {}\n\n        // Parse Frontmatter\n        const frontmatterRegex = /^---\\r?\\n([\\s\\S]*?)\\r?\\n---/\n        const match = markdown.match(frontmatterRegex)\n        if (match) {\n            try {\n                metadata = yaml.load(match[1] as string) as Record<string, any>\n                content = markdown.slice(match[0].length).trim()\n            } catch (e) {\n                console.error('Failed to parse Agent frontmatter:', e)\n            }\n        }\n\n        const lines = content.split(/\\r?\\n/)\n        const sections: AgentSection[] = []\n        let title = metadata.name ?? 'Unknown Agent'\n        let currentSection: AgentSection | null = null\n        let currentContent: string[] = []\n\n        for (const line of lines) {\n            // Parse Title (Only if not already set by frontmatter)\n            if (line.startsWith('# ') && !metadata.name) {\n                const rawTitle = line.replace('# ', '').trim()\n                // Handle \"AGENT CONTEXT: [Name]\" format\n                if (rawTitle.toUpperCase().startsWith('AGENT CONTEXT:')) {\n                    title = rawTitle\n                        .slice(14)\n                        .replace(/^[:\\s-]+/, '')\n                        .trim()\n                } else {\n                    title = rawTitle\n                }\n                continue\n            }\n\n            // Parse Sections\n            if (line.startsWith('## ')) {\n                // Save previous section\n                if (currentSection) {\n                    currentSection.content = currentContent.join('\\n').trim()\n                    sections.push(currentSection)\n                }\n\n                currentSection = {\n                    title: line.replace('## ', '').trim(),\n                    content: '',\n                }\n                currentContent = []\n                continue\n            }\n\n            // Collect content\n            if (currentSection) {\n                currentContent.push(line)\n            }\n        }\n\n        // Save last section\n        if (currentSection) {\n            currentSection.content = currentContent.join('\\n').trim()\n            sections.push(currentSection)\n        }\n\n        return {\n            title,\n            sections,\n            metadata,\n        }\n    }\n}\n","import { existsSync } from 'node:fs'\nimport { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'\n\nimport { AUTONOMOS_DIR } from '../constants'\n\n/**\n * Markers that identify the root of an Autonomos / git project.\n *\n * `.autonomos/` is a strong signal: if it exists, the project has already\n * been initialized with the protocol and the directory containing it is,\n * by definition, the project root.\n *\n * `.git/` is a weaker signal: it only tells us the directory is inside a\n * git working tree. We still stop at the first `.git/` we see, which is\n * good enough for the common monorepo case (the monorepo root contains\n * the `.git/`, package subdirectories do not).\n */\nconst PROJECT_MARKERS = [AUTONOMOS_DIR, '.git'] as const\n\n/**\n * Find the directory that owns this project by walking up from `startDir`\n * until we find a directory containing `.autonomos/` or `.git/`.\n *\n * Returns `null` if no such directory exists before we reach the\n * filesystem root.\n *\n * Notes on behavior:\n * - The search stops at the first directory that contains any of the\n *   markers. For monorepos this is the monorepo root, not the package\n *   directory the caller is sitting in.\n * - A directory containing `.git/` is preferred over walking further up:\n *   this prevents leaking into a parent repository in nested-worktree\n *   setups. Callers that need the absolute git toplevel can run\n *   `git rev-parse --show-toplevel` themselves after this returns.\n *\n * @param startDir - Absolute path to start the search from.\n */\nexport function findProjectRoot(startDir: string): string | null {\n    if (!startDir) return null\n    const start = resolve(startDir)\n    let current = start\n\n    while (true) {\n        if (PROJECT_MARKERS.some(marker => existsSync(join(current, marker)))) {\n            return current\n        }\n        const parent = dirname(current)\n        if (parent === current) return null\n        current = parent\n    }\n}\n\n/**\n * Check whether two absolute paths refer to the same directory.\n *\n * Resolves `.` / `..` segments before comparing, so `/a/b` and\n * `/a/b/./` are considered the same.\n */\nexport function isSamePath(a: string, b: string): boolean {\n    if (!a || !b) return false\n    return resolve(a) === resolve(b)\n}\n\n/**\n * Render a path relative to another path, with one guarantee that the\n * default `path.relative` doesn't give us: we never return a value that\n * starts with `..`. If `target` is not under `base`, we return the\n * absolute resolved path of `target` so the caller can still show a\n * useful location.\n */\nexport function displayRelative(target: string, base: string): string {\n    const rel = relative(base, target)\n    if (rel === '' || rel === '.') return '.'\n    if (rel.startsWith(`..${sep}`) || rel === '..' || isAbsolute(rel)) {\n        return resolve(target)\n    }\n    return rel\n}\n","import type { Complexity, Priority, Task, TaskStatus } from '../types'\n\nexport class TaskParser {\n    static parse(markdown: string): Task[] {\n        const tasks: Task[] = []\n        const lines = markdown.split(/\\r?\\n/)\n        const taskRegex = /- \\[([ x/!])\\] \\*\\*\\[(.+)\\]\\*\\* (.+) `Priority: (.+)` `Complexity: (.+)`/\n\n        for (const line of lines) {\n            const match = line.match(taskRegex)\n            if (match) {\n                const [, statusChar = ' ', id = '', title = '', priority = '', complexity = ''] =\n                    match\n                tasks.push({\n                    id,\n                    title: title.trim(),\n                    priority: priority as Priority,\n                    complexity: complexity as Complexity,\n                    status: this.mapStatus(statusChar),\n                })\n            }\n        }\n        return tasks\n    }\n\n    private static mapStatus(char: string): TaskStatus {\n        switch (char) {\n            case ' ':\n                return 'TODO'\n            case '/':\n                return 'IN_PROGRESS'\n            case 'x':\n                return 'DONE'\n            case '!':\n                return 'BLOCKED'\n            default:\n                return 'TODO'\n        }\n    }\n}\n","","import harnessCodesData from './data/harness-codes.json' with { type: 'json' }\nimport {\n    HarnessCodesSchema,\n    type Harness,\n    type HarnessCodes,\n    type Installer,\n} from './schemas/harness-codes'\n\n/**\n * Validated, in-memory representation of the harness codes config.\n * Loaded once at module init, validated via Zod.\n */\nconst codes: HarnessCodes = HarnessCodesSchema.parse(harnessCodesData)\n\n/**\n * Get a single harness entry by its id.\n * Throws if the id is unknown.\n */\nexport function getHarness(id: string): Harness {\n    const entry = codes.platforms[id]\n    if (!entry) {\n        const known = Object.keys(codes.platforms).join(', ')\n        throw new Error(`Unknown harness: \"${id}\". Known harnesses: ${known}`)\n    }\n    return entry\n}\n\n/**\n * List all configured harnesses, as an array of {id, harness} pairs.\n * Stable order: insertion order of the JSON object.\n */\nexport function listHarnesses(): Array<{ id: string; harness: Harness }> {\n    return Object.entries(codes.platforms).map(([id, harness]) => ({ id, harness }))\n}\n\n/**\n * Get the list of preferred harnesses (shown as recommended options).\n */\nexport function listPreferredHarnesses(): Array<{ id: string; harness: Harness }> {\n    return listHarnesses().filter(({ harness }) => harness.preferred)\n}\n\n/**\n * A resolved target directory where workflow files will be written.\n * One per unique path, with the list of harness ids that share it.\n */\nexport interface ResolvedTarget {\n    /** Absolute or project-relative path to the directory */\n    path: string\n    /** File extension to use (e.g. \".md\", \".agent.md\") */\n    fileExtension: string\n    /** Ids of the harnesses that will read from this directory */\n    usedBy: string[]\n}\n\n/**\n * Resolve the unique target directories for a set of harness ids.\n *\n * Harnesses that share the same `skillsDir` (e.g. Codex, OpenCode, KiloCode\n * all use `.agents/skills/`) are deduplicated: the directory appears once\n * in the output, with all the harness ids listed in `usedBy`.\n *\n * The `path` is returned relative to the project root (caller is responsible\n * for joining with the project cwd).\n */\nexport function resolveTargets(harnessIds: string[], cwd: string = '.'): ResolvedTarget[] {\n    const map = new Map<string, ResolvedTarget>()\n\n    for (const id of harnessIds) {\n        const { installer } = getHarness(id)\n        collectFromInstaller(map, installer, id, cwd)\n    }\n\n    return Array.from(map.values())\n}\n\nfunction collectFromInstaller(\n    map: Map<string, ResolvedTarget>,\n    installer: Installer,\n    harnessId: string,\n    cwd: string\n): void {\n    const ext = installer.fileExtension\n    if (installer.workflowsDir) {\n        addTarget(map, joinPath(cwd, installer.workflowsDir), ext, harnessId)\n    } else if (installer.targetDir) {\n        addTarget(map, joinPath(cwd, installer.targetDir), ext, harnessId)\n    } else if (installer.skillsDir) {\n        addTarget(map, joinPath(cwd, installer.skillsDir), ext, harnessId)\n    }\n    if (installer.commandsDir) {\n        addTarget(map, joinPath(cwd, installer.commandsDir), ext, harnessId)\n    }\n}\n\nfunction addTarget(\n    map: Map<string, ResolvedTarget>,\n    path: string,\n    fileExtension: string,\n    harnessId: string\n): void {\n    const existing = map.get(path)\n    if (existing) {\n        if (!existing.usedBy.includes(harnessId)) {\n            existing.usedBy.push(harnessId)\n        }\n    } else {\n        map.set(path, { path, fileExtension, usedBy: [harnessId] })\n    }\n}\n\nfunction joinPath(a: string, b: string): string {\n    if (a === '.' || a === '') return b\n    if (b.startsWith('/')) return `${a}${b}`\n    return `${a}/${b}`\n}\n\n/**\n * Get the raw (validated) codes object, for advanced use cases.\n * Most callers should use the higher-level helpers above.\n */\nexport function getRawHarnessCodes(): HarnessCodes {\n    return codes\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["harnessCodesData"],"sources":["../src/constants.ts","../src/schemas/harness-codes.ts","../src/schemas/manifest.ts","../src/types.ts","../src/templates/agent.ts","../src/templates/manifest.ts","../src/templates/protocol.ts","../src/templates/tasks.ts","../src/templates/worklog.ts","../src/parsers/agent-finder.ts","../src/parsers/agent-parser.ts","../src/parsers/project-root.ts","../src/parsers/task-parser.ts","../src/data/harness-codes.json","../src/harness-codes.ts"],"sourcesContent":["/**\n * Agent Protocol Specification Version (Independent of Package versions)\n * This refers to the schema and behavioral contract version.\n */\nexport const PROTOCOL_VERSION = '0.5.0-alpha'\n\n/**\n * Directory name for Autonomos configuration\n */\nexport const AUTONOMOS_DIR = '.autonomos'\n\n/**\n * Manifest filename\n */\nexport const MANIFEST_FILE = 'manifest.json'\n\n/**\n * Protocol filename\n */\nexport const PROTOCOL_FILE = 'PROTOCOL.md'\n\n/**\n * Tasks filename\n */\nexport const TASKS_FILE = 'TASKS.md'\n\n/**\n * Agent context filename (at project root)\n */\nexport const AGENT_FILE = 'AGENT.md'\n\n/**\n * Worklogs directory name\n */\nexport const WORKLOGS_DIR = 'worklogs'\n\n/**\n * Optional project-owned directory for durable target-state specifications\n */\nexport const SPECS_DIR = 'specs'\n\n/**\n * Optional project-owned directory for technical decision records (ADRs)\n */\nexport const DECISIONS_DIR = 'decisions'\n","import { z } from 'zod'\n\n/**\n * Installer configuration for a single harness.\n *\n * At least one of `workflowsDir`, `targetDir`, or `skillsDir` must be defined.\n *\n * - `workflowsDir`: Where the protocol workflow files are written.\n *    Preferred field — used by most harnesses.\n * - `targetDir`: Single directory (legacy, like Cline's .clinerules/workflows/).\n * - `skillsDir`: Skills directory (legacy, for harnesses that don't distinguish\n *    skills from workflows).\n * - `commandsDir`: Additional commands directory (optional).\n */\nexport const InstallerSchema = z\n    .object({\n        workflowsDir: z.string().optional(),\n        targetDir: z.string().optional(),\n        skillsDir: z.string().optional(),\n        commandsDir: z.string().optional(),\n        globalTargetDir: z.string().optional(),\n        fileExtension: z.string(),\n    })\n    .refine(\n        data => Boolean(data.workflowsDir) || Boolean(data.targetDir) || Boolean(data.skillsDir),\n        {\n            message: 'At least one of `workflowsDir`, `targetDir`, or `skillsDir` must be defined',\n        }\n    )\n\n/**\n * A single harness entry.\n */\nexport const HarnessSchema = z.object({\n    name: z.string().min(1),\n    preferred: z.boolean(),\n    installer: InstallerSchema,\n})\n\n/**\n * Root schema for the harness-codes configuration file.\n */\nexport const HarnessCodesSchema = z.object({\n    platforms: z.record(z.string(), HarnessSchema),\n})\n\nexport type Installer = z.infer<typeof InstallerSchema>\nexport type Harness = z.infer<typeof HarnessSchema>\nexport type HarnessCodes = z.infer<typeof HarnessCodesSchema>\n","import { z } from 'zod'\n\n/**\n * Manifest Schema for .autonomos/manifest.json\n */\nexport const ManifestSchema = z.object({\n    protocolVersion: z.string().describe('Version of the Agent Protocol specification'),\n    cliVersion: z.string().describe('Version of the CLI that last updated this project'),\n    initializedAt: z.string().datetime().describe('ISO timestamp of project initialization'),\n    lastUpdated: z.string().datetime().describe('ISO timestamp of last protocol update'),\n})\n\nexport type Manifest = z.infer<typeof ManifestSchema>\n","/**\n * Priority levels for tasks\n */\nexport type Priority = '🔴 Critical' | '🟠 High' | '🔵 Medium' | '⚪ Low'\n\n/**\n * Complexity estimates for tasks\n */\nexport type Complexity = 'S' | 'M' | 'L' | 'XL'\n\n/**\n * Task status markers\n */\nexport type TaskStatus = 'TODO' | 'IN_PROGRESS' | 'DONE' | 'BLOCKED'\n\n/**\n * Task entity parsed from TASKS.md\n */\nexport interface Task {\n    id: string\n    title: string\n    priority: Priority\n    complexity: Complexity\n    status: TaskStatus\n    worklogPath?: string\n}\n\n/**\n * Agent configuration parsed from AGENT.md\n */\nexport interface AgentConfig {\n    name: string\n    description?: string\n    stack: string[]\n    preferences?: Record<string, any>\n}\n\nexport interface AgentSection {\n    title: string\n    content: string\n}\n\nexport interface AgentContext {\n    title: string\n    description?: string\n    sections: AgentSection[]\n    metadata?: Record<string, any>\n}\n\nexport const PRIORITIES: Priority[] = ['🔴 Critical', '🟠 High', '🔵 Medium', '⚪ Low']\nexport const COMPLEXITIES: Complexity[] = ['S', 'M', 'L', 'XL']\n","/**\n * Template for AGENT.md - The context anchor at project root\n * @param projectName - Name of the project to personalize the template\n */\nexport function generateAgentTemplate(projectName: string = 'Project'): string {\n    return `---\nname: \"${projectName}\"\ntype: \"project\"\nstatus: \"active\"\n---\n# AGENT CONTEXT: ${projectName}\n\n## 🧠 Context & Objectives\n\n*Describe what this project does and its main goals.*\n\n## ⚙️ Workflow & Preferences\n\n- **Commits:** Conventional Commits\n- **Language:** English\n\n## 🏗 Stack & Architecture\n\n- **Tech:** *(List frameworks, libraries)*\n- **Patterns:** *(Architecture patterns used)*\n\n## 📁 Key Directories\n\n| Path | Description |\n|------|-------------|\n| \\`src/\\` | Source code |\n| \\`.autonomos/\\` | Agent Protocol files |\n\n## ⚠️ Known Constraints\n\n*List any technical debts, missing features, or external limitations.*\n`\n}\n\n/**\n * Generate a minimal local AGENT.md for subdirectories.\n * Free format by design — low friction encourages creation.\n * @param dirName - Name of the directory\n */\nexport function generateLocalAgentTemplate(dirName: string): string {\n    return `# AGENT: ${dirName}\n\n- **Stack:** *(frameworks, libs specific to this module)*\n- **Conventions:** *(naming, exports, test patterns)*\n- **Constraints:** *(known issues, tech debt)*\n`\n}\n\n/**\n * Default root AGENT.md template\n */\nexport const AGENT_TEMPLATE = generateAgentTemplate()\n\n/**\n * Default local AGENT.md template\n */\nexport const LOCAL_AGENT_TEMPLATE = generateLocalAgentTemplate('module')\n","import { PROTOCOL_VERSION } from '../constants'\nimport { ManifestSchema, type Manifest } from '../schemas/manifest'\n\n/**\n * Creates a new manifest object with current timestamps\n */\nexport function createManifest(cliVersion: string): Manifest {\n    const now = new Date().toISOString()\n    return {\n        protocolVersion: PROTOCOL_VERSION,\n        cliVersion,\n        initializedAt: now,\n        lastUpdated: now,\n    }\n}\n\n/**\n * Generates the manifest.json content as a formatted string\n */\nexport function generateManifestContent(manifest: Manifest): string {\n    return JSON.stringify(manifest, null, 4) + '\\n'\n}\n\n/**\n * Parses manifest.json content into a Manifest object with validation\n */\nexport function parseManifest(content: string): Manifest {\n    const data = JSON.parse(content)\n    return ManifestSchema.parse(data)\n}\n","import { PROTOCOL_VERSION } from '../constants'\n\n/**\n * The Protocol kernel template — v0.5\n *\n * Design principles (v0.5):\n * - PROTOCOL.md is a compact REFERENCE, not an executable workflow.\n * - All step-by-step instructions live in the workflow files.\n * - No duplication between PROTOCOL.md and workflows.\n * - Short enough that an LLM can re-scan it mid-session without cost.\n */\nexport const PROTOCOL_TEMPLATE = `# AUTONOMOS PROTOCOL (v${PROTOCOL_VERSION})\n\n> This file defines the project's AI workflow contract. The workflows execute it. Do not duplicate workflow steps here.\n\n## Quick Reference\n\n| Action                           | How                                                                                |\n| -------------------------------- | ---------------------------------------------------------------------------------- |\n| Start a session                  | Read the \\`/session\\` workflow                                                       |\n| Start a task                     | Read the \\`/task\\` workflow                                                          |\n| Triage a problem or proposal     | Read the optional \\`/issue\\` workflow                                                |\n| Adopt existing project knowledge | Read the optional \\`/adopt\\` workflow                                                |\n| Audit accumulated drift          | Read the \\`/reconcile\\` workflow                                                     |\n| End a session                    | Read the \\`/crystallize\\` workflow                                                   |\n| Get context                      | Read root \\`AGENT.md\\`, then only the selected scope's ancestor chain                |\n| Resolve objective                | Explicit user request first; otherwise resume \\`[/]\\` or pick highest-priority \\`[ ]\\` |\n| Log session work                 | Create \\`.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md\\`                               |\n\n## File Map\n\n| File            | Location                   | Role                                              |\n| --------------- | -------------------------- | ------------------------------------------------- |\n| \\`AGENT.md\\`      | Root + any subdirectory    | Durable guidance for its directory scope          |\n| \\`TASKS.md\\`      | \\`.autonomos/TASKS.md\\`      | Single source of truth for task state             |\n| \\`ISSUES.md\\`     | \\`.autonomos/ISSUES.md\\`     | Optional problem, proposal, and question intake   |\n| \\`worklogs/\\`     | \\`.autonomos/worklogs/\\`     | Historical session evidence, not current guidance |\n| \\`specs/\\`        | \\`.autonomos/specs/\\`        | Optional project-owned normative target state     |\n| \\`decisions/\\`    | \\`.autonomos/decisions/\\`    | Optional project-owned decision records (ADRs)    |\n| \\`PROTOCOL.md\\`   | \\`.autonomos/PROTOCOL.md\\`   | This file — read-only reference                   |\n| \\`manifest.json\\` | \\`.autonomos/manifest.json\\` | Protocol version metadata                         |\n\n## AGENT.md Format Rules\n\nStore only stable guidance that will affect different future tasks. Keep transient evidence in worklogs and operational explanations in component documentation. Use the narrowest applicable \\`AGENT.md\\`; consolidate or replace obsolete entries instead of appending history.\n\n**Root \\`AGENT.md\\`** — Must use the structured template (frontmatter + sections: Context, Workflow, Stack, Key Directories, Constraints).\n\n**Local \\`AGENT.md\\`** (in any subdirectory) — Free format. One line is enough if it is clear. What matters: the next session can use it. Example:\n\n\\`\\`\\`markdown\n# AGENT: packages/core\n\n- Stack: TypeScript, Vitest, tsdown\n- Conventions: exports via src/index.ts, tests co-located (\\\\*.test.ts)\n- Constraint: template changes require workflow test updates\n\\`\\`\\`\n\n## Issue, Specification, Decision, and Task Rules\n\nIssues describe evidence, impact, and a desired outcome without choosing implementation; proposed directions remain hypotheses until an approach is accepted. Specifications describe accepted target behavior or requirements that may guide multiple tasks. A decision record (commonly ADR, Architecture Decision Record) captures one technical choice and its rationale. Tasks describe an accepted intervention and completion criteria. Use optional \\`ISSUES.md\\`, \\`specs/\\`, and \\`decisions/\\` only when they provide value; direct, clear changes may become tasks immediately. Link related issues, specs, decisions, and tasks in both directions.\n\n## Specification and Decision Rules\n\n- \\`.autonomos/specs/\\` and \\`.autonomos/decisions/\\` are optional, project-owned, first-use directories; \\`init\\`, \\`update\\`, and artifact-integrity checks do not create or overwrite them.\n- Keep one Markdown file per bounded specification or decision. Include status, scope, provenance, acceptance criteria or consequences, and replacement links where relevant; no parser or independent version is required initially.\n- Specification status is \\`draft\\`, \\`accepted\\`, or \\`superseded\\`. Only \\`accepted\\` is normative; \\`superseded\\` points to its successor. Acceptance does not mean implementation is complete.\n- Decision records use \\`proposed\\`, \\`accepted\\`, or \\`superseded\\`; they preserve rationale and alternatives rather than duplicating the full specification.\n- Keep stable agent operating rules in \\`AGENT.md\\`, user/developer reference in \\`docs/\\`, execution state in \\`TASKS.md\\`, and historical evidence in \\`worklogs/\\`.\n- Read only relevant accepted records at task start. Use \\`/adopt\\` to extract legacy knowledge; never rewrite historical worklogs, issues, or tasks to create current artifacts.\n\nThe protocol-facing name is **decision record**. **ADR** (Architecture Decision Record) is a common convention for the same kind of document, not a required external standard. Use these lightweight Markdown shapes as a starting point; they are conventions, not parser-enforced schemas:\n\n\\`\\`\\`markdown\n# SPEC-001 — Concise target-state title\n\n- Status: draft | accepted | superseded\n- Scope: component, capability, or boundary\n- Provenance: issue, discussion, or source links\n- Related decisions: ADR-001, ...\n- Superseded by: SPEC-002 (when applicable)\n\n## Intent\n\n## Requirements\n\n## Acceptance criteria\n\n## Out of scope\n\\`\\`\\`\n\n\\`\\`\\`markdown\n# ADR-001 — Concise decision title\n\n- Status: proposed | accepted | superseded\n- Scope: component or technical boundary\n- Provenance: issue, task, or investigation links\n- Related specs: SPEC-001, ...\n- Superseded by: ADR-002 (when applicable)\n\n## Context\n\n## Decision\n\n## Alternatives considered\n\n## Consequences\n\\`\\`\\`\n\nOnly user/project governance accepts a specification or decision as normative. Agents may draft and link records, but must not silently promote them; acceptance is separate from implementation completion.\n\n## Task Format\n\n\\`- [Status] **[ID]** Title \\\\\\`Priority\\\\\\` \\\\\\`Complexity\\\\\\`\\`\n\n| Status            | Priority      | Complexity |\n| ----------------- | ------------- | ---------- |\n| \\`[ ]\\` Todo        | \\`🔴 Critical\\` | \\`S\\` Small  |\n| \\`[/]\\` In Progress | \\`🟠 High\\`     | \\`M\\` Medium |\n| \\`[x]\\` Done        | \\`🔵 Medium\\`   | \\`L\\` Large  |\n| \\`[!]\\` Blocked     | \\`⚪ Low\\`      | \\`XL\\` Huge  |\n\n## Metadata Rules\n\n- **Language:** English unless AGENT.md says otherwise.\n- **Tone:** Technical, concise, fact-based.\n- **Continuity:** Refer to previous work as \"we\" or \"the project\".\n`\n\n/**\n * @deprecated Use PROTOCOL_TEMPLATE instead\n */\nexport const PROTOCOL_TEMPLATE_V2026_1 = PROTOCOL_TEMPLATE\n","/**\n * Template for TASKS.md - The task registry\n */\nexport const TASKS_TEMPLATE = `# PROJECT TASKS & ROADMAP\n\n> **LEGEND**\n> **Priority:** [🔴 Critical] [🟠 High] [🔵 Medium] [⚪ Low]\n> **Complexity:** [S] Small (1h), [M] Medium (4h), [L] Large (1-2 days), [XL] Huge (Planning req.)\n> **Status:** [ ] Todo, [/] In Progress, [x] Done, [!] Blocked\n\n## 🚀 Active Sprint\n\n- [ ] **[INIT-01]** Review project context and structure \\`Priority: 🔵\\` \\`Complexity: S\\`\n\n## 🔮 Backlog\n\n*(Add future tasks here)*\n`\n","import type { TaskStatus } from '../types'\n\ninterface WorklogOptions {\n    taskId: string\n    taskName: string\n    date?: string\n    status: 'Complete' | 'Partial' | 'Blocked'\n    description: string\n    filesModified: string[]\n    decisions: string[]\n    challenges: string[]\n    nextSteps: string[]\n}\n\n/**\n * Generate a Worklog markdown content\n */\nexport function generateWorklogContent(options: WorklogOptions): string {\n    const date = options.date ?? new Date().toISOString().split('T')[0]\n\n    return `# WORKLOG: [${options.taskId}] ${options.taskName}\n**Date:** ${date}\n**Agent Status:** [${options.status}]\n\n## 📝 Description\n${options.description}\n\n## 🛠 Technical Details\n- **Files Modified:**\n${options.filesModified.map(f => `  - ${f}`).join('\\n')}\n- **Key Decisions:**\n${options.decisions.map(d => `  - ${d}`).join('\\n')}\n- **Challenges:**\n${options.challenges.map(c => `  - ${c}`).join('\\n')}\n\n## ⏭ Next Steps / Context for Successor\n${options.nextSteps.map(s => `- ${s}`).join('\\n')}\n`\n}\n\n/**\n * Common status mapping for worklogs\n */\nexport function mapTaskStatusToWorklogStatus(\n    status: TaskStatus\n): 'Complete' | 'Partial' | 'Blocked' {\n    switch (status) {\n        case 'DONE':\n            return 'Complete'\n        case 'BLOCKED':\n            return 'Blocked'\n        default:\n            return 'Partial'\n    }\n}\n","import { existsSync, statSync } from 'node:fs'\nimport { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'\n\nimport { AGENT_FILE } from '../constants'\n\n/**\n * Result of an ancestor lookup: a single AGENT.md entry that exists on the\n * path between a target file or directory and the project root.\n */\nexport interface AncestorAgent {\n    /** Absolute path to the directory containing the AGENT.md */\n    dir: string\n    /** Absolute path to the AGENT.md file */\n    path: string\n    /** Path of the directory relative to the project root */\n    relativeDir: string\n}\n\n/**\n * Return the ordered list of AGENT.md files that exist on the path from a\n * target file or directory up to the project root. The order is root-first,\n * then each intermediate directory, then the target directory itself.\n *\n * Non-existent AGENT.md files are silently skipped (the chain can have gaps).\n *\n * @param target - The absolute or project-relative path to a file or directory.\n * @param projectRoot - The absolute path of the project root (where the root\n *   AGENT.md lives). Defaults to the current working directory.\n *\n * @example\n *   findAncestorAgents('/proj/apps/web/components/ui/button.tsx', '/proj')\n *   // Returns, in order:\n *   // - { dir: '/proj',                path: '/proj/AGENT.md' }\n *   // - { dir: '/proj/apps/web',       path: '/proj/apps/web/AGENT.md' }\n *   // (apps/, components/ skipped because they have no AGENT.md)\n *   // (button.tsx itself is a file, so its parent dir is the last one checked)\n */\nexport function findAncestorAgents(\n    target: string,\n    projectRoot: string = process.cwd()\n): AncestorAgent[] {\n    const absRoot = resolve(projectRoot)\n    const absTarget = resolveAgainstRoot(target, absRoot)\n\n    // Validate that the target lives within the project root\n    const relToRoot = relative(absRoot, absTarget)\n    if (relToRoot.startsWith('..') || isAbsolute(relToRoot)) {\n        throw new Error(\n            `Target \"${target}\" is outside the project root \"${absRoot}\". ` +\n                `findAncestorAgents only handles paths within the project.`\n        )\n    }\n\n    // Collect every directory from the target up to the root, in root-first order.\n    // For a file target, we only look at the directory chain (not the file itself).\n    // For a directory target, the directory itself is included as the last entry.\n    const targetDir = isDirectory(absTarget) ? absTarget : dirname(absTarget)\n    const dirs = collectAncestorDirs(targetDir, absRoot)\n\n    const result: AncestorAgent[] = []\n    for (const dir of dirs) {\n        const agentPath = join(dir, AGENT_FILE)\n        if (existsSync(agentPath)) {\n            result.push({\n                dir,\n                path: agentPath,\n                relativeDir: relativeDir(dir, absRoot),\n            })\n        }\n    }\n\n    return result\n}\n\n/**\n * Resolve a target path against the project root. Accepts absolute paths\n * (returned as-is) and project-relative paths (joined with the root).\n */\nfunction resolveAgainstRoot(target: string, absRoot: string): string {\n    if (isAbsolute(target)) return target\n    return join(absRoot, target)\n}\n\n/**\n * Return the directory chain from a starting directory up to (and including)\n * the project root, in root-first order. The chain is computed by walking\n * the relative path segments from the starting dir back to the root.\n */\nfunction collectAncestorDirs(startDir: string, absRoot: string): string[] {\n    const rel = relative(absRoot, startDir)\n    if (rel === '' || rel === '.') {\n        return [absRoot]\n    }\n\n    const segments = rel.split(sep).filter(s => s !== '' && s !== '.')\n    const chain: string[] = [absRoot]\n    let acc = absRoot\n    for (const seg of segments) {\n        acc = join(acc, seg)\n        chain.push(acc)\n    }\n    return chain\n}\n\n/**\n * Compute the directory's path relative to the project root, in a form\n * suitable for display. The root itself is rendered as \".\".\n */\nfunction relativeDir(dir: string, absRoot: string): string {\n    const rel = relative(absRoot, dir)\n    return rel === '' ? '.' : rel\n}\n\nfunction isDirectory(p: string): boolean {\n    try {\n        return statSync(p).isDirectory()\n    } catch {\n        return false\n    }\n}\n","import yaml from 'js-yaml'\nimport type { AgentContext, AgentSection } from '../types'\n\nexport class AgentParser {\n    /**\n     * Parse an AGENT.md content into a structured AgentContext\n     */\n    static parse(markdown: string): AgentContext {\n        let content = markdown\n        let metadata: Record<string, any> = {}\n\n        // Parse Frontmatter\n        const frontmatterRegex = /^---\\r?\\n([\\s\\S]*?)\\r?\\n---/\n        const match = markdown.match(frontmatterRegex)\n        if (match) {\n            try {\n                metadata = yaml.load(match[1] as string) as Record<string, any>\n                content = markdown.slice(match[0].length).trim()\n            } catch (e) {\n                console.error('Failed to parse Agent frontmatter:', e)\n            }\n        }\n\n        const lines = content.split(/\\r?\\n/)\n        const sections: AgentSection[] = []\n        let title = metadata.name ?? 'Unknown Agent'\n        let currentSection: AgentSection | null = null\n        let currentContent: string[] = []\n\n        for (const line of lines) {\n            // Parse Title (Only if not already set by frontmatter)\n            if (line.startsWith('# ') && !metadata.name) {\n                const rawTitle = line.replace('# ', '').trim()\n                // Handle \"AGENT CONTEXT: [Name]\" format\n                if (rawTitle.toUpperCase().startsWith('AGENT CONTEXT:')) {\n                    title = rawTitle\n                        .slice(14)\n                        .replace(/^[:\\s-]+/, '')\n                        .trim()\n                } else {\n                    title = rawTitle\n                }\n                continue\n            }\n\n            // Parse Sections\n            if (line.startsWith('## ')) {\n                // Save previous section\n                if (currentSection) {\n                    currentSection.content = currentContent.join('\\n').trim()\n                    sections.push(currentSection)\n                }\n\n                currentSection = {\n                    title: line.replace('## ', '').trim(),\n                    content: '',\n                }\n                currentContent = []\n                continue\n            }\n\n            // Collect content\n            if (currentSection) {\n                currentContent.push(line)\n            }\n        }\n\n        // Save last section\n        if (currentSection) {\n            currentSection.content = currentContent.join('\\n').trim()\n            sections.push(currentSection)\n        }\n\n        return {\n            title,\n            sections,\n            metadata,\n        }\n    }\n}\n","import { existsSync } from 'node:fs'\nimport { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'\n\nimport { AUTONOMOS_DIR } from '../constants'\n\n/**\n * Markers that identify the root of an Autonomos / git project.\n *\n * `.autonomos/` is a strong signal: if it exists, the project has already\n * been initialized with the protocol and the directory containing it is,\n * by definition, the project root.\n *\n * `.git/` is a weaker signal: it only tells us the directory is inside a\n * git working tree. We still stop at the first `.git/` we see, which is\n * good enough for the common monorepo case (the monorepo root contains\n * the `.git/`, package subdirectories do not).\n */\nconst PROJECT_MARKERS = [AUTONOMOS_DIR, '.git'] as const\n\n/**\n * Find the directory that owns this project by walking up from `startDir`\n * until we find a directory containing `.autonomos/` or `.git/`.\n *\n * Returns `null` if no such directory exists before we reach the\n * filesystem root.\n *\n * Notes on behavior:\n * - The search stops at the first directory that contains any of the\n *   markers. For monorepos this is the monorepo root, not the package\n *   directory the caller is sitting in.\n * - A directory containing `.git/` is preferred over walking further up:\n *   this prevents leaking into a parent repository in nested-worktree\n *   setups. Callers that need the absolute git toplevel can run\n *   `git rev-parse --show-toplevel` themselves after this returns.\n *\n * @param startDir - Absolute path to start the search from.\n */\nexport function findProjectRoot(startDir: string): string | null {\n    if (!startDir) return null\n    const start = resolve(startDir)\n    let current = start\n\n    while (true) {\n        if (PROJECT_MARKERS.some(marker => existsSync(join(current, marker)))) {\n            return current\n        }\n        const parent = dirname(current)\n        if (parent === current) return null\n        current = parent\n    }\n}\n\n/**\n * Check whether two absolute paths refer to the same directory.\n *\n * Resolves `.` / `..` segments before comparing, so `/a/b` and\n * `/a/b/./` are considered the same.\n */\nexport function isSamePath(a: string, b: string): boolean {\n    if (!a || !b) return false\n    return resolve(a) === resolve(b)\n}\n\n/**\n * Render a path relative to another path, with one guarantee that the\n * default `path.relative` doesn't give us: we never return a value that\n * starts with `..`. If `target` is not under `base`, we return the\n * absolute resolved path of `target` so the caller can still show a\n * useful location.\n */\nexport function displayRelative(target: string, base: string): string {\n    const rel = relative(base, target)\n    if (rel === '' || rel === '.') return '.'\n    if (rel.startsWith(`..${sep}`) || rel === '..' || isAbsolute(rel)) {\n        return resolve(target)\n    }\n    return rel\n}\n","import type { Complexity, Priority, Task, TaskStatus } from '../types'\n\nexport class TaskParser {\n    static parse(markdown: string): Task[] {\n        const tasks: Task[] = []\n        const lines = markdown.split(/\\r?\\n/)\n        const taskRegex = /- \\[([ x/!])\\] \\*\\*\\[(.+)\\]\\*\\* (.+) `Priority: (.+)` `Complexity: (.+)`/\n\n        for (const line of lines) {\n            const match = line.match(taskRegex)\n            if (match) {\n                const [, statusChar = ' ', id = '', title = '', priority = '', complexity = ''] =\n                    match\n                tasks.push({\n                    id,\n                    title: title.trim(),\n                    priority: priority as Priority,\n                    complexity: complexity as Complexity,\n                    status: this.mapStatus(statusChar),\n                })\n            }\n        }\n        return tasks\n    }\n\n    private static mapStatus(char: string): TaskStatus {\n        switch (char) {\n            case ' ':\n                return 'TODO'\n            case '/':\n                return 'IN_PROGRESS'\n            case 'x':\n                return 'DONE'\n            case '!':\n                return 'BLOCKED'\n            default:\n                return 'TODO'\n        }\n    }\n}\n","","import harnessCodesData from './data/harness-codes.json' with { type: 'json' }\nimport {\n    HarnessCodesSchema,\n    type Harness,\n    type HarnessCodes,\n    type Installer,\n} from './schemas/harness-codes'\n\n/**\n * Validated, in-memory representation of the harness codes config.\n * Loaded once at module init, validated via Zod.\n */\nconst codes: HarnessCodes = HarnessCodesSchema.parse(harnessCodesData)\n\n/**\n * Get a single harness entry by its id.\n * Throws if the id is unknown.\n */\nexport function getHarness(id: string): Harness {\n    const entry = codes.platforms[id]\n    if (!entry) {\n        const known = Object.keys(codes.platforms).join(', ')\n        throw new Error(`Unknown harness: \"${id}\". Known harnesses: ${known}`)\n    }\n    return entry\n}\n\n/**\n * List all configured harnesses, as an array of {id, harness} pairs.\n * Stable order: insertion order of the JSON object.\n */\nexport function listHarnesses(): Array<{ id: string; harness: Harness }> {\n    return Object.entries(codes.platforms).map(([id, harness]) => ({ id, harness }))\n}\n\n/**\n * Get the list of preferred harnesses (shown as recommended options).\n */\nexport function listPreferredHarnesses(): Array<{ id: string; harness: Harness }> {\n    return listHarnesses().filter(({ harness }) => harness.preferred)\n}\n\n/**\n * A resolved target directory where workflow files will be written.\n * One per unique path, with the list of harness ids that share it.\n */\nexport interface ResolvedTarget {\n    /** Absolute or project-relative path to the directory */\n    path: string\n    /** File extension to use (e.g. \".md\", \".agent.md\") */\n    fileExtension: string\n    /** Ids of the harnesses that will read from this directory */\n    usedBy: string[]\n}\n\n/**\n * Resolve the unique target directories for a set of harness ids.\n *\n * Harnesses that share the same `skillsDir` (e.g. Codex, OpenCode, KiloCode\n * all use `.agents/skills/`) are deduplicated: the directory appears once\n * in the output, with all the harness ids listed in `usedBy`.\n *\n * The `path` is returned relative to the project root (caller is responsible\n * for joining with the project cwd).\n */\nexport function resolveTargets(harnessIds: string[], cwd: string = '.'): ResolvedTarget[] {\n    const map = new Map<string, ResolvedTarget>()\n\n    for (const id of harnessIds) {\n        const { installer } = getHarness(id)\n        collectFromInstaller(map, installer, id, cwd)\n    }\n\n    return Array.from(map.values())\n}\n\nfunction collectFromInstaller(\n    map: Map<string, ResolvedTarget>,\n    installer: Installer,\n    harnessId: string,\n    cwd: string\n): void {\n    const ext = installer.fileExtension\n    if (installer.workflowsDir) {\n        addTarget(map, joinPath(cwd, installer.workflowsDir), ext, harnessId)\n    } else if (installer.targetDir) {\n        addTarget(map, joinPath(cwd, installer.targetDir), ext, harnessId)\n    } else if (installer.skillsDir) {\n        addTarget(map, joinPath(cwd, installer.skillsDir), ext, harnessId)\n    }\n    if (installer.commandsDir) {\n        addTarget(map, joinPath(cwd, installer.commandsDir), ext, harnessId)\n    }\n}\n\nfunction addTarget(\n    map: Map<string, ResolvedTarget>,\n    path: string,\n    fileExtension: string,\n    harnessId: string\n): void {\n    const existing = map.get(path)\n    if (existing) {\n        if (!existing.usedBy.includes(harnessId)) {\n            existing.usedBy.push(harnessId)\n        }\n    } else {\n        map.set(path, { path, fileExtension, usedBy: [harnessId] })\n    }\n}\n\nfunction joinPath(a: string, b: string): string {\n    if (a === '.' || a === '') return b\n    if (b.startsWith('/')) return `${a}${b}`\n    return `${a}/${b}`\n}\n\n/**\n * Get the raw (validated) codes object, for advanced use cases.\n * Most callers should use the higher-level helpers above.\n */\nexport function getRawHarnessCodes(): HarnessCodes {\n    return codes\n}\n"],"mappings":"oMAIA,MAAa,EAAmB,cAKnB,EAAgB,aAKhB,EAAgB,gBAKhB,EAAgB,cAKhB,EAAa,WAKb,EAAa,WAKb,GAAe,WAKf,EAAY,QAKZ,EAAgB,YC9BhB,EAAkB,EAC1B,OAAO,CACJ,aAAc,EAAE,OAAO,CAAC,CAAC,SAAS,EAClC,UAAW,EAAE,OAAO,CAAC,CAAC,SAAS,EAC/B,UAAW,EAAE,OAAO,CAAC,CAAC,SAAS,EAC/B,YAAa,EAAE,OAAO,CAAC,CAAC,SAAS,EACjC,gBAAiB,EAAE,OAAO,CAAC,CAAC,SAAS,EACrC,cAAe,EAAE,OAAO,CAC5B,CAAC,CAAC,CACD,OACG,GAAQ,EAAQ,EAAK,cAAiB,EAAQ,EAAK,WAAc,EAAQ,EAAK,UAC9E,CACI,QAAS,6EACb,CACJ,EAKS,EAAgB,EAAE,OAAO,CAClC,KAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EACtB,UAAW,EAAE,QAAQ,EACrB,UAAW,CACf,CAAC,EAKY,EAAqB,EAAE,OAAO,CACvC,UAAW,EAAE,OAAO,EAAE,OAAO,EAAG,CAAa,CACjD,CAAC,ECvCY,EAAiB,EAAE,OAAO,CACnC,gBAAiB,EAAE,OAAO,CAAC,CAAC,SAAS,6CAA6C,EAClF,WAAY,EAAE,OAAO,CAAC,CAAC,SAAS,mDAAmD,EACnF,cAAe,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,yCAAyC,EACvF,YAAa,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,uCAAuC,CACvF,CAAC,ECuCY,EAAyB,CAAC,cAAe,UAAW,YAAa,OAAO,EACxE,EAA6B,CAAC,IAAK,IAAK,IAAK,IAAI,EC9C9D,SAAgB,EAAsB,EAAsB,UAAmB,CAC3E,MAAO;SACF,EAAY;;;;mBAIF,EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B/B,CAOA,SAAgB,EAA2B,EAAyB,CAChE,MAAO,YAAY,EAAQ;;;;;CAM/B,CAKA,MAAa,GAAiB,EAAsB,EAKvC,EAAuB,EAA2B,QAAQ,ECvDvE,SAAgB,EAAe,EAA8B,CACzD,IAAM,EAAM,IAAI,KAAK,CAAA,CAAE,YAAY,EACnC,MAAO,CACH,gBAAiB,EACjB,aACA,cAAe,EACf,YAAa,CACjB,CACJ,CAKA,SAAgB,EAAwB,EAA4B,CAChE,OAAO,KAAK,UAAU,EAAU,KAAM,CAAC,EAAI;CAC/C,CAKA,SAAgB,EAAc,EAA2B,CACrD,IAAM,EAAO,KAAK,MAAM,CAAO,EAC/B,OAAO,EAAe,MAAM,CAAI,CACpC,CClBA,MAAa,EAAoB,0BAA0B,EAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyH/D,EAA4B,ECjI5B,EAAiB;;;;;;;;;;;;;;ECc9B,SAAgB,EAAuB,EAAiC,CACpE,IAAM,EAAO,EAAQ,MAAQ,IAAI,KAAK,CAAA,CAAE,YAAY,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,GAEjE,MAAO,eAAe,EAAQ,OAAO,IAAI,EAAQ,SAAS;YAClD,EAAK;qBACI,EAAQ,OAAO;;;EAGlC,EAAQ,YAAY;;;;EAIpB,EAAQ,cAAc,IAAI,GAAK,OAAO,GAAG,CAAC,CAAC,KAAK;CAAI,EAAE;;EAEtD,EAAQ,UAAU,IAAI,GAAK,OAAO,GAAG,CAAC,CAAC,KAAK;CAAI,EAAE;;EAElD,EAAQ,WAAW,IAAI,GAAK,OAAO,GAAG,CAAC,CAAC,KAAK;CAAI,EAAE;;;EAGnD,EAAQ,UAAU,IAAI,GAAK,KAAK,GAAG,CAAC,CAAC,KAAK;CAAI,EAAE;CAElD,CAKA,SAAgB,EACZ,EACkC,CAClC,OAAQ,EAAR,CACI,IAAK,OACD,MAAO,WACX,IAAK,UACD,MAAO,UACX,QACI,MAAO,SACf,CACJ,CCjBA,SAAgB,EACZ,EACA,EAAsB,QAAQ,IAAI,EACnB,CACf,IAAM,EAAU,EAAQ,CAAW,EAC7B,EAAY,EAAmB,EAAQ,CAAO,EAG9C,EAAY,EAAS,EAAS,CAAS,EAC7C,GAAI,EAAU,WAAW,IAAI,GAAK,EAAW,CAAS,EAClD,MAAU,MACN,WAAW,EAAO,iCAAiC,EAAQ,6DAE/D,EAOJ,IAAM,EAAO,EADK,EAAY,CAAS,EAAI,EAAY,EAAQ,CAAS,EAC5B,CAAO,EAE7C,EAA0B,CAAC,EACjC,IAAK,IAAM,KAAO,EAAM,CACpB,IAAM,EAAY,EAAK,EAAK,CAAU,EAClC,EAAW,CAAS,GACpB,EAAO,KAAK,CACR,MACA,KAAM,EACN,YAAa,EAAY,EAAK,CAAO,CACzC,CAAC,CAET,CAEA,OAAO,CACX,CAMA,SAAS,EAAmB,EAAgB,EAAyB,CAEjE,OADI,EAAW,CAAM,EAAU,EACxB,EAAK,EAAS,CAAM,CAC/B,CAOA,SAAS,EAAoB,EAAkB,EAA2B,CACtE,IAAM,EAAM,EAAS,EAAS,CAAQ,EACtC,GAAI,IAAQ,IAAM,IAAQ,IACtB,MAAO,CAAC,CAAO,EAGnB,IAAM,EAAW,EAAI,MAAM,CAAG,CAAC,CAAC,OAAO,GAAK,IAAM,IAAM,IAAM,GAAG,EAC3D,EAAkB,CAAC,CAAO,EAC5B,EAAM,EACV,IAAK,IAAM,KAAO,EACd,EAAM,EAAK,EAAK,CAAG,EACnB,EAAM,KAAK,CAAG,EAElB,OAAO,CACX,CAMA,SAAS,EAAY,EAAa,EAAyB,CACvD,IAAM,EAAM,EAAS,EAAS,CAAG,EACjC,OAAO,IAAQ,GAAK,IAAM,CAC9B,CAEA,SAAS,EAAY,EAAoB,CACrC,GAAI,CACA,OAAO,EAAS,CAAC,CAAC,CAAC,YAAY,CACnC,MAAQ,CACJ,MAAO,EACX,CACJ,CCpHA,IAAa,EAAb,KAAyB,CAIrB,OAAO,MAAM,EAAgC,CACzC,IAAI,EAAU,EACV,EAAgC,CAAC,EAI/B,EAAQ,EAAS,MAAM,6BAAgB,EAC7C,GAAI,EACA,GAAI,CACA,EAAW,EAAK,KAAK,EAAM,EAAY,EACvC,EAAU,EAAS,MAAM,EAAM,EAAE,CAAC,MAAM,CAAC,CAAC,KAAK,CACnD,OAAS,EAAG,CACR,QAAQ,MAAM,qCAAsC,CAAC,CACzD,CAGJ,IAAM,EAAQ,EAAQ,MAAM,OAAO,EAC7B,EAA2B,CAAC,EAC9B,EAAQ,EAAS,MAAQ,gBACzB,EAAsC,KACtC,EAA2B,CAAC,EAEhC,IAAK,IAAM,KAAQ,EAAO,CAEtB,GAAI,EAAK,WAAW,IAAI,GAAK,CAAC,EAAS,KAAM,CACzC,IAAM,EAAW,EAAK,QAAQ,KAAM,EAAE,CAAC,CAAC,KAAK,EAE7C,AAMI,EANA,EAAS,YAAY,CAAC,CAAC,WAAW,gBAAgB,EAC1C,EACH,MAAM,EAAE,CAAC,CACT,QAAQ,WAAY,EAAE,CAAC,CACvB,KAAK,EAEF,EAEZ,QACJ,CAGA,GAAI,EAAK,WAAW,KAAK,EAAG,CAEpB,IACA,EAAe,QAAU,EAAe,KAAK;CAAI,CAAC,CAAC,KAAK,EACxD,EAAS,KAAK,CAAc,GAGhC,EAAiB,CACb,MAAO,EAAK,QAAQ,MAAO,EAAE,CAAC,CAAC,KAAK,EACpC,QAAS,EACb,EACA,EAAiB,CAAC,EAClB,QACJ,CAGI,GACA,EAAe,KAAK,CAAI,CAEhC,CAQA,OALI,IACA,EAAe,QAAU,EAAe,KAAK;CAAI,CAAC,CAAC,KAAK,EACxD,EAAS,KAAK,CAAc,GAGzB,CACH,QACA,WACA,UACJ,CACJ,CACJ,EC9DA,MAAM,EAAkB,CAAC,EAAe,MAAM,EAoB9C,SAAgB,EAAgB,EAAiC,CAC7D,GAAI,CAAC,EAAU,OAAO,KAEtB,IAAI,EADU,EAAQ,CACJ,EAElB,OAAa,CACT,GAAI,EAAgB,KAAK,GAAU,EAAW,EAAK,EAAS,CAAM,CAAC,CAAC,EAChE,OAAO,EAEX,IAAM,EAAS,EAAQ,CAAO,EAC9B,GAAI,IAAW,EAAS,OAAO,KAC/B,EAAU,CACd,CACJ,CAQA,SAAgB,EAAW,EAAW,EAAoB,CAEtD,MADI,CAAC,GAAK,CAAC,EAAU,GACd,EAAQ,CAAC,IAAM,EAAQ,CAAC,CACnC,CASA,SAAgB,EAAgB,EAAgB,EAAsB,CAClE,IAAM,EAAM,EAAS,EAAM,CAAM,EAKjC,OAJI,IAAQ,IAAM,IAAQ,IAAY,IAClC,EAAI,WAAW,KAAK,GAAK,GAAK,IAAQ,MAAQ,EAAW,CAAG,EACrD,EAAQ,CAAM,EAElB,CACX,CC3EA,IAAa,EAAb,KAAwB,CACpB,OAAO,MAAM,EAA0B,CACnC,IAAM,EAAgB,CAAC,EACjB,EAAQ,EAAS,MAAM,OAAO,EAC9B,EAAY,2EAElB,IAAK,IAAM,KAAQ,EAAO,CACtB,IAAM,EAAQ,EAAK,MAAM,CAAS,EAClC,GAAI,EAAO,CACP,GAAM,EAAG,EAAa,IAAK,EAAK,GAAI,EAAQ,GAAI,EAAW,GAAI,EAAa,IACxE,EACJ,EAAM,KAAK,CACP,KACA,MAAO,EAAM,KAAK,EACR,WACE,aACZ,OAAQ,KAAK,UAAU,CAAU,CACrC,CAAC,CACL,CACJ,CACA,OAAO,CACX,CAEA,OAAe,UAAU,EAA0B,CAC/C,OAAQ,EAAR,CACI,IAAK,IACD,MAAO,OACX,IAAK,IACD,MAAO,cACX,IAAK,IACD,MAAO,OACX,IAAK,IACD,MAAO,UACX,QACI,MAAO,MACf,CACJ,CACJ,EE3BA,MAAM,EAAsB,EAAmB,MAAMA,2kDAAAA,CAAgB,EAMrE,SAAgB,EAAW,EAAqB,CAC5C,IAAM,EAAQ,EAAM,UAAU,GAC9B,GAAI,CAAC,EAAO,CACR,IAAM,EAAQ,OAAO,KAAK,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI,EACpD,MAAU,MAAM,qBAAqB,EAAG,sBAAsB,GAAO,CACzE,CACA,OAAO,CACX,CAMA,SAAgB,GAAyD,CACrE,OAAO,OAAO,QAAQ,EAAM,SAAS,CAAC,CAAC,KAAK,CAAC,EAAI,MAAc,CAAE,KAAI,SAAQ,EAAE,CACnF,CAKA,SAAgB,GAAkE,CAC9E,OAAO,EAAc,CAAC,CAAC,QAAQ,CAAE,aAAc,EAAQ,SAAS,CACpE,CAyBA,SAAgB,EAAe,EAAsB,EAAc,IAAuB,CACtF,IAAM,EAAM,IAAI,IAEhB,IAAK,IAAM,KAAM,EAAY,CACzB,GAAM,CAAE,aAAc,EAAW,CAAE,EACnC,EAAqB,EAAK,EAAW,EAAI,CAAG,CAChD,CAEA,OAAO,MAAM,KAAK,EAAI,OAAO,CAAC,CAClC,CAEA,SAAS,EACL,EACA,EACA,EACA,EACI,CACJ,IAAM,EAAM,EAAU,cAClB,EAAU,aACV,EAAU,EAAK,EAAS,EAAK,EAAU,YAAY,EAAG,EAAK,CAAS,EAC7D,EAAU,UACjB,EAAU,EAAK,EAAS,EAAK,EAAU,SAAS,EAAG,EAAK,CAAS,EAC1D,EAAU,WACjB,EAAU,EAAK,EAAS,EAAK,EAAU,SAAS,EAAG,EAAK,CAAS,EAEjE,EAAU,aACV,EAAU,EAAK,EAAS,EAAK,EAAU,WAAW,EAAG,EAAK,CAAS,CAE3E,CAEA,SAAS,EACL,EACA,EACA,EACA,EACI,CACJ,IAAM,EAAW,EAAI,IAAI,CAAI,EACzB,EACK,EAAS,OAAO,SAAS,CAAS,GACnC,EAAS,OAAO,KAAK,CAAS,EAGlC,EAAI,IAAI,EAAM,CAAE,OAAM,gBAAe,OAAQ,CAAC,CAAS,CAAE,CAAC,CAElE,CAEA,SAAS,EAAS,EAAW,EAAmB,CAG5C,OAFI,IAAM,KAAO,IAAM,GAAW,EAC9B,EAAE,WAAW,GAAG,EAAU,GAAG,IAAI,IAC9B,GAAG,EAAE,GAAG,GACnB,CAMA,SAAgB,IAAmC,CAC/C,OAAO,CACX"}

package/dist/workflows/protocol-adopt.md

@@ -0,0 +1,39 @@
+---
+name: protocol-adopt
+description: 'Adopt optional specifications and decision records without rewriting project history.'
+---
+
+# /adopt — Organize project knowledge
+
+> This is an explicit, reviewable migration. It never expands user authority.
+
+## STEP 1 — Establish scope
+
+1. Confirm the target area and read root → target `AGENT.md` files.
+2. Read `.autonomos/PROTOCOL.md`, relevant issues, tasks, worklogs, and candidate Markdown.
+3. Keep the inventory bounded; do not load unrelated context branches.
+
+## STEP 2 — Classify sources
+
+- Target behavior or requirements → `.autonomos/specs/`
+- One technical choice and its rationale → `.autonomos/decisions/`
+- Stable operating guidance → `AGENT.md`
+- User/developer reference → `docs/`
+- Historical or uncertain material → preserve and report
+
+## STEP 3 — Propose before writing
+
+Create a source → destination map with scope, provenance, confidence, and conflicts.
+Do not rewrite `worklogs/`, `ISSUES.md`, `TASKS.md`, or managed protocol artifacts.
+
+## STEP 4 — Confirm and apply
+
+Show the map and unresolved conflicts to the user before writing.
+After approval, create or update only approved project-owned artifacts.
+Copy and link by default; move or remove sources only with explicit approval.
+Keep extracted specifications `draft` and decisions `proposed` until accepted.
+
+## STEP 5 — Verify
+
+Check links, duplicates, scope, status, and acceptance criteria.
+Record the migration in a new worklog, then run `/reconcile` for a second pass.

package/dist/workflows/protocol-crystallize.md

@@ -6,6 +6,7 @@ description: 'Mandatory close-out before ending a session. Forces durable knowle
 # /crystallize — End session
 
 > **CRITICAL:** You MUST NOT ask the user what to crystallize. This is YOUR job. Reflect, decide, write. Then inform the user what you saved.
+> **Authority:** If the user limited the work to read-only or no changes, do not modify any artifact; deliver the substantive answer and report that crystallization was skipped.
 
 ## STEP 1 — Worklog
 
@@ -16,17 +17,19 @@ Create `.autonomos/worklogs/YYYY-MM-DD-[TASK_ID].md` containing:
 - Files modified
 - Next steps for the next session
 
-## STEP 2 — Crystallize into AGENT.md
+## STEP 2 — Route knowledge
 
-Ask yourself silently — do NOT ask the user:
+For each candidate ask: **Would this still guide a different future task?**
 
-1. **What did I learn?** (preferences, constraints, conventions, corrections) → Write to the relevant AGENT.md.
-2. **Is any AGENT.md entry now wrong?** → Replace in place, log the change in the worklog.
-3. **Should a new local AGENT.md exist?** (worked in a folder with >5 files and no AGENT.md) → Create one, free format.
+- **No:** keep observations, measurements, chronology, and completed actions in the worklog.
+- **Operational explanation:** update existing component documentation when within scope.
+- **Yes:** route stable operating guidance to the narrowest `AGENT.md`, target requirements to `specs/`, and decision rationale to `decisions/`; keep each non-duplicated.
+
+Consolidate or replace superseded and disproven guidance; do not turn historical worklogs, issues, or tasks into current specs/decisions without `/adopt`. Never create an `AGENT.md` based on file count alone.
 
 ## STEP 3 — Task status
 
-Mark the task `[x]` (or `[!]` if blocked) in `.autonomos/TASKS.md`.
+Mark `[x]` only if complete, `[!]` only if an unresolved dependency prevents progress, or keep `[/]` for partial work.
 
 ## STEP 4 — User response
 
@@ -34,4 +37,4 @@ First, deliver a self-contained answer to the original request: outcome, evidenc
 
 Then append this supplementary handoff:
 
-`Crystallization — Task: [x] / [!] — [ID] | Worklog: .autonomos/worklogs/... | AGENT.md updated: [yes / no — reason]`
+`Crystallization — Task: [x] / [/] / [!] — [ID] | Worklog: .autonomos/worklogs/... | AGENT.md updated: [yes / no — reason]`

package/dist/workflows/protocol-issue.md

@@ -0,0 +1,39 @@
+---
+name: protocol-issue
+description: 'Optional intake for problems, proposals, and questions before choosing implementation.'
+---
+
+# /issue — Capture and triage
+
+> Use this workflow only when the need or solution requires triage. A direct, clear, authorized change may start as a task.
+> Proposed directions remain hypotheses until an approach is accepted.
+
+## STEP 1 — Build context
+
+1. Read root and applicable root → target `AGENT.md` files.
+2. Read `.autonomos/ISSUES.md` if it exists and search for duplicates.
+3. Read related tasks or worklogs only when they provide evidence.
+
+## STEP 2 — Record the signal
+
+Create `.autonomos/ISSUES.md` on first use. Record without prescribing implementation:
+
+```markdown
+## [ISSUE-ID] Concise title
+
+- Type: problem | proposal | question
+- Status: open | accepted | resolved | declined
+- Evidence: observed facts or motivation
+- Impact: why it matters
+- Desired outcome: solution-independent success
+- Tasks: none | TASK-ID, ...
+```
+
+Merge duplicate evidence into the existing issue instead of creating another.
+
+## STEP 3 — Triage
+
+- **Open:** preserve the signal; do not create a task before an approach is accepted.
+- **Accepted:** create one or more scoped tasks through `/task` and link both directions.
+  If the outcome spans tasks, create or link a specification; record each consequential technical choice separately.
+- **Resolved/declined:** record the outcome and concise rationale; preserve the issue as history.

package/dist/workflows/protocol-reconcile.md

@@ -0,0 +1,34 @@
+---
+name: protocol-reconcile
+description: 'Audit and safely reconcile accumulated drift across Autonomos artifacts.'
+---
+
+# /reconcile — Audit and repair drift
+
+> Reconciliation is evidence-driven and bounded by user authority. Never guess through a semantic conflict or rewrite history to match the present.
+
+## STEP 1 — Inventory and classify
+
+1. Read root and applicable scoped `AGENT.md` files, then current tasks, optional issues, relevant worklogs, linked documentation, and any existing `specs/` or `decisions/`.
+2. Classify each artifact as current guidance, current state, historical evidence, or version-pinned protocol content.
+3. Check protocol integrity with `autonomos status`; repair managed artifacts only through `autonomos update` when authorized.
+
+## STEP 2 — Detect drift
+
+Look for duplicates, contradictions, obsolete paths or technologies, misplaced knowledge, vague rules, broken references, and task/issue/worklog status mismatches.
+
+## STEP 3 — Verify
+
+1. Test each finding against authoritative repository source, configuration, tests, and current scoped documentation.
+2. Use runtime or external evidence only when access is authorized and necessary.
+3. Classify the result as **certain**, **uncertain**, or **historical-only**.
+
+## STEP 4 — Reconcile
+
+- **Certain:** make the smallest correction; consolidate duplicates, route misplaced content, and replace or remove disproven current guidance.
+- **Uncertain:** do not mutate the disputed facts; report evidence, conflict, and concrete resolution options to the user.
+- **Historical-only:** preserve it unless it exposes sensitive data or falsely claims to be current guidance.
+- Missing optional `specs/` or `decisions/` are adoption candidates; do not create them automatically.
+- Use `/adopt` for history-to-artifact extraction; keep `/reconcile` focused on bounded audit and correction.
+
+Record material corrections and validation in the task worklog. Re-run checks and stop when a second pass produces no deterministic changes.

package/dist/workflows/protocol-session.md

@@ -5,28 +5,29 @@ description: 'Mandatory bootstrap for any new session. Invoke before any work be
 
 # /session — Start
 
-**You MUST complete Steps 1–3 before writing any code.**
+> **Authority:** The protocol never expands the user's requested scope. Answer-only, read-only, and diagnosis-without-fix requests remain non-mutating.
 
-## STEP 1 — Load context
+## STEP 1 — Orient
 
-1. Run `find . -name AGENT.md -not -path '*/node_modules/*'` and read every file found, root-first.
-2. Read the most recent file in `.autonomos/worklogs/` (if any).
-3. Read `.autonomos/TASKS.md`.
+1. Read the root `AGENT.md`.
+2. Read `.autonomos/TASKS.md`.
 
-RESPOND with a **3-line max** summary of what you retained. Do not continue without this response.
+RESPOND with a **3-line max** summary of relevant project context. Do not continue without this response.
 
-## STEP 2 — Select task
+## STEP 2 — Resolve the objective
 
-Pick the highest-priority task not marked `[x]` or `[!]`. If none, ask the user.
+1. If the user supplied an objective, it takes precedence. Match a task, use `/issue` for untriaged signals, or register a task for a clear authorized change.
+2. For non-mutating work, load only the context needed, answer, and do not start a task.
+3. Without a user objective, resume a `[/]` task; otherwise pick the highest-priority `[ ]` task. If none exists, ask the user.
 
-RESPOND: `Task: [ID] — [title]. Starting.`
+RESPOND: `Task: [ID] — [title]. Starting.` when a task will run.
 
-## STEP 3 — Mark and begin
+## STEP 3 — Begin
 
-Set the task to `[/]` in `.autonomos/TASKS.md`. Now you may work.
+Invoke `/task`; it owns scoped context, planning, and the `[/]` transition.
 
-## Session rules (apply until session ends)
+## Session rules
 
-1. **Before every non-trivial decision:** check if an AGENT.md says something about it.
-2. **Every time you learn something new** (user correction, discovered convention, technical choice): write it to the relevant AGENT.md **now**, not later.
-3. **When the session ends:** invoke the `/crystallize` workflow. You cannot close without it.
+1. Before non-trivial decisions, consult the applicable root → target `AGENT.md` chain.
+2. Capture durable knowledge according to `/crystallize`, within user authority.
+3. When authorized task work ends, invoke `/crystallize`.

package/dist/workflows/protocol-task.md

@@ -5,12 +5,16 @@ description: 'Mandatory procedure before starting a new task. Invoke before touc
 
 # /task — Begin a task
 
+> **Authority:** Enter execution only for changes the user authorized. Answer-only, read-only, and diagnosis-without-fix requests must not mutate protocol or project artifacts.
+
 **Do NOT touch code before Step 2 is done.**
 
 ## STEP 1 — Build fractal context
 
 1. From the target file/folder, walk up to the project root. Read every `AGENT.md` you find on that path (root → target).
-2. If no local `AGENT.md` exists at the target and you have worked in that folder before, propose creating one.
+2. Read the linked issue when present; if resuming, read the task's most recent worklog.
+3. If present, read only relevant accepted specifications and decision records; drafts/proposals inform exploration, superseded records do not constrain work.
+4. Do not load unrelated worklogs or context branches.
 
 ## STEP 2 — Declare plan
 
@@ -23,9 +27,9 @@ Mark the task `[/]` in `.autonomos/TASKS.md`, then work.
 ## During execution
 
 1. **Before every non-trivial decision:** consult the relevant AGENT.md.
-2. **Every new learning:** append to an AGENT.md immediately. If it contradicts an existing entry, replace in place and note the change in the worklog.
-3. **Root AGENT.md** uses the structured template. **Local AGENT.md** files are free format — one line is enough.
+2. Treat new information as a crystallization candidate, not an automatic `AGENT.md` entry.
+3. Keep session evidence with the task; route durable guidance only during `/crystallize`.
 
 ## End of task
 
-Mark `[x]` in TASKS.md. Invoke `/crystallize`.
+Mark `[x]` only if complete, `[!]` only if an unresolved dependency prevents progress, or keep `[/]` for partial work. Invoke `/crystallize`.

package/dist/workflows/protocol-workflows.test.ts

@@ -5,11 +5,12 @@ import { PROTOCOL_TEMPLATE } from '../templates/protocol'
 
 /**
  * Validates the content of all workflow files and the PROTOCOL_TEMPLATE.
- * These tests guard against regressions on the v0.3 design:
+ * These tests guard against regressions on the v0.5 design:
  * - No crystallization questions directed at the user
  * - No duplicated close-out procedures in session.md
- * - find-based AGENT.md discovery (no CLI dependency in workflows)
- * - Consistent AGENT.md format rules
+ * - Scoped AGENT.md discovery (no CLI dependency in workflows)
+ * - Durable-memory admission, placement, and retirement
+ * - Project-owned specifications, decision records, and safe adoption
  * - Workflows are short enough to fit in LLM working memory
  */
 
@@ -20,6 +21,9 @@ function loadWorkflow(name: string): string {
 const session = loadWorkflow('protocol-session.md')
 const crystallize = loadWorkflow('protocol-crystallize.md')
 const task = loadWorkflow('protocol-task.md')
+const issue = loadWorkflow('protocol-issue.md')
+const reconcile = loadWorkflow('protocol-reconcile.md')
+const adopt = loadWorkflow('protocol-adopt.md')
 
 // ---------------------------------------------------------------------------
 // 1. Crystallization — agent-directed, never asks the user
@@ -30,7 +34,7 @@ describe('crystallize.md — self-directed crystallization', () => {
     })
 
     it('directs the agent to ask itself', () => {
-        expect(crystallize).toContain('Ask yourself silently')
+        expect(crystallize).toContain('For each candidate ask')
     })
 
     it('does not contain a user-questioning pattern', () => {
@@ -43,7 +47,7 @@ describe('crystallize.md — self-directed crystallization', () => {
         expect(crystallize).toContain('outcome, evidence, limitations, and relevant next step')
         expect(crystallize).not.toContain('RESPOND with exactly')
         expect(crystallize.indexOf('self-contained answer')).toBeLessThan(
-            crystallize.indexOf('supplementary handoff'),
+            crystallize.indexOf('supplementary handoff')
         )
     })
 })
@@ -72,19 +76,24 @@ describe('session.md — clean separation of concerns', () => {
 })
 
 // ---------------------------------------------------------------------------
-// 3. AGENT.md discovery — find-based, no CLI dependency
+// 3. Scoped context discovery and workflow composition
 // ---------------------------------------------------------------------------
-describe('AGENT.md discovery — universal method', () => {
-    it('session.md uses find as primary method', () => {
-        expect(session).toContain('find . -name AGENT.md')
+describe('Scoped context discovery and workflow composition', () => {
+    it('orients from root without loading every context branch', () => {
+        expect(session).toContain('Read the root `AGENT.md`')
+        expect(session).not.toContain('find . -name AGENT.md')
     })
 
-    it('task.md uses directory walk, not CLI', () => {
-        // task.md should instruct walking up the directory tree
+    it('task.md loads only the target ancestor chain and relevant worklog', () => {
         expect(task).toContain('walk up')
-        // Should NOT require autonomos CLI as a mandatory step
+        expect(task).toContain('Do not load unrelated worklogs or context branches')
         expect(task).not.toContain('npx --yes @autonomos/cli')
     })
+
+    it('delegates scoped planning and task transition to /task', () => {
+        expect(session).toContain('Invoke `/task`')
+        expect(session).toContain('it owns scoped context, planning, and the `[/]` transition')
+    })
 })
 
 // ---------------------------------------------------------------------------
@@ -96,24 +105,17 @@ describe('AGENT.md format rules — consistent across files', () => {
         expect(session).toContain('AGENT.md')
     })
 
-    it('task.md clarifies root vs local format', () => {
-        expect(task).toContain('Root AGENT.md')
-        expect(task).toContain('free format')
-    })
-
-    it('crystallize.md allows free format for local files', () => {
-        expect(crystallize).toContain('free format')
-    })
-
-    it('PROTOCOL_TEMPLATE has explicit format rules section', () => {
+    it('PROTOCOL_TEMPLATE owns root vs local format rules', () => {
         expect(PROTOCOL_TEMPLATE).toContain('Format Rules')
+        expect(PROTOCOL_TEMPLATE).toContain('Root `AGENT.md`')
+        expect(PROTOCOL_TEMPLATE).toContain('Local `AGENT.md`')
     })
 })
 
 // ---------------------------------------------------------------------------
 // 5. PROTOCOL_TEMPLATE — compact reference, no workflow duplication
 // ---------------------------------------------------------------------------
-describe('PROTOCOL_TEMPLATE — v0.3 design', () => {
+describe('PROTOCOL_TEMPLATE — v0.5 design', () => {
     it('does not contain Phase 1/2/3 workflow steps', () => {
         expect(PROTOCOL_TEMPLATE).not.toContain('Phase 1:')
         expect(PROTOCOL_TEMPLATE).not.toContain('Phase 2:')
@@ -123,6 +125,9 @@ describe('PROTOCOL_TEMPLATE — v0.3 design', () => {
     it('points to workflows as the executable contract', () => {
         expect(PROTOCOL_TEMPLATE).toContain('/session')
         expect(PROTOCOL_TEMPLATE).toContain('/task')
+        expect(PROTOCOL_TEMPLATE).toContain('/issue')
+        expect(PROTOCOL_TEMPLATE).toContain('/adopt')
+        expect(PROTOCOL_TEMPLATE).toContain('/reconcile')
         expect(PROTOCOL_TEMPLATE).toContain('/crystallize')
     })
 
@@ -138,10 +143,159 @@ describe('PROTOCOL_TEMPLATE — v0.3 design', () => {
         expect(PROTOCOL_TEMPLATE).toContain('.autonomos/TASKS.md')
         expect(PROTOCOL_TEMPLATE).toContain('.autonomos/worklogs/')
     })
+
+    it('documents scoped context and intent-first objective resolution', () => {
+        expect(PROTOCOL_TEMPLATE).toContain("selected scope's ancestor chain")
+        expect(PROTOCOL_TEMPLATE).toContain('Explicit user request first')
+        expect(PROTOCOL_TEMPLATE).not.toContain('find . -name AGENT.md')
+    })
+
+    it('distinguishes durable guidance from historical evidence', () => {
+        expect(PROTOCOL_TEMPLATE).toContain('Durable guidance for its directory scope')
+        expect(PROTOCOL_TEMPLATE).toContain('Historical session evidence')
+        expect(PROTOCOL_TEMPLATE).toContain('consolidate or replace obsolete entries')
+    })
 })
 
 // ---------------------------------------------------------------------------
-// 6. Workflow brevity — each must be concise enough for LLM working memory
+// 6. Durable-memory admission, placement, and retirement
+// ---------------------------------------------------------------------------
+describe('Durable-memory lifecycle', () => {
+    it('does not append every learning immediately', () => {
+        expect(task).toContain('crystallization candidate')
+        expect(task).not.toContain('Every new learning')
+        expect(task).not.toContain('append to an AGENT.md immediately')
+    })
+
+    it('routes session evidence, operational docs, and durable guidance separately', () => {
+        expect(crystallize).toContain('Would this still guide a different future task?')
+        expect(crystallize).toContain('observations, measurements, chronology')
+        expect(crystallize).toContain('existing component documentation')
+        expect(crystallize).toContain('stable operating guidance')
+        expect(crystallize).toContain('target requirements to `specs/`')
+        expect(crystallize).toContain('decision rationale to `decisions/`')
+    })
+
+    it('retires stale guidance and rejects arbitrary file-count heuristics', () => {
+        expect(crystallize).toContain('Consolidate or replace superseded and disproven guidance')
+        expect(crystallize).toContain(
+            'do not turn historical worklogs, issues, or tasks into current specs/decisions'
+        )
+        expect(crystallize).toContain('Never create an `AGENT.md` based on file count alone')
+    })
+})
+
+// ---------------------------------------------------------------------------
+// 7. Optional issue intake and task separation
+// ---------------------------------------------------------------------------
+describe('Issue intake and task separation', () => {
+    it('keeps issue intake optional for requests that need triage', () => {
+        expect(issue).toContain('Use this workflow only when the need or solution requires triage')
+        expect(issue).toContain('A direct, clear, authorized change may start as a task')
+        expect(PROTOCOL_TEMPLATE).toContain('optional `ISSUES.md`')
+    })
+
+    it('records solution-independent evidence before implementation', () => {
+        expect(issue).toContain('Record without prescribing implementation')
+        expect(issue).toContain('Evidence: observed facts or motivation')
+        expect(issue).toContain('Desired outcome: solution-independent success')
+        expect(issue).toContain('search for duplicates')
+    })
+
+    it('creates tasks only after acceptance and links both directions', () => {
+        expect(issue).toContain('do not create a task before an approach is accepted')
+        expect(issue).toContain('create one or more scoped tasks through `/task`')
+        expect(issue).toContain('link both directions')
+        expect(PROTOCOL_TEMPLATE).toContain('Tasks describe an accepted intervention')
+    })
+})
+
+// ---------------------------------------------------------------------------
+// 8. Project-owned specifications, decisions, and adoption
+// ---------------------------------------------------------------------------
+describe('Project knowledge boundaries and adoption', () => {
+    it('defines optional specifications and decision records without automation', () => {
+        expect(PROTOCOL_TEMPLATE).toContain('`.autonomos/specs/`')
+        expect(PROTOCOL_TEMPLATE).toContain('`.autonomos/decisions/`')
+        expect(PROTOCOL_TEMPLATE).toContain('do not create or overwrite them')
+        expect(PROTOCOL_TEMPLATE).toContain(
+            'no parser or independent version is required initially'
+        )
+        expect(PROTOCOL_TEMPLATE).toContain('Acceptance does not mean implementation is complete')
+    })
+
+    it('routes accepted target state separately from decisions and history', () => {
+        expect(task).toContain('accepted specifications and decision records')
+        expect(issue).toContain('Proposed directions remain hypotheses')
+        expect(crystallize).toContain('target requirements to `specs/`')
+        expect(crystallize).toContain('decision rationale to `decisions/`')
+        expect(reconcile).toContain('Use `/adopt` for history-to-artifact extraction')
+    })
+
+    it('requires a reviewable, additive adoption pass', () => {
+        expect(adopt).toContain('source → destination map')
+        expect(adopt).toContain('Show the map and unresolved conflicts to the user before writing')
+        expect(adopt).toContain('Do not rewrite `worklogs/`, `ISSUES.md`, `TASKS.md`')
+        expect(adopt).toContain('Copy and link by default')
+        expect(adopt).toContain('run `/reconcile` for a second pass')
+    })
+})
+
+// ---------------------------------------------------------------------------
+// 9. Evidence-aware reconciliation
+// ---------------------------------------------------------------------------
+describe('Evidence-aware reconciliation', () => {
+    it('classifies current, historical, and version-pinned artifacts', () => {
+        expect(reconcile).toContain('current guidance, current state, historical evidence')
+        expect(reconcile).toContain('version-pinned protocol content')
+        expect(reconcile).toContain('autonomos status')
+        expect(reconcile).toContain('autonomos update')
+    })
+
+    it('checks the expected drift classes against authoritative evidence', () => {
+        expect(reconcile).toContain('duplicates, contradictions, obsolete paths or technologies')
+        expect(reconcile).toContain('authoritative repository source, configuration, tests')
+        expect(reconcile).toContain('certain**, **uncertain**, or **historical-only')
+    })
+
+    it('corrects only certain findings and converges idempotently', () => {
+        expect(reconcile).toContain('Certain:** make the smallest correction')
+        expect(reconcile).toContain('Uncertain:** do not mutate the disputed facts')
+        expect(reconcile).toContain('Historical-only:** preserve it')
+        expect(reconcile).toContain('second pass produces no deterministic changes')
+    })
+})
+
+// ---------------------------------------------------------------------------
+// 10. User authority and truthful lifecycle status
+// ---------------------------------------------------------------------------
+describe('User authority and lifecycle status', () => {
+    it('keeps answer-only, read-only, and diagnostic requests non-mutating', () => {
+        expect(session).toContain("never expands the user's requested scope")
+        expect(session).toContain('answer, and do not start a task')
+        expect(task).toContain('diagnosis-without-fix requests must not mutate')
+        expect(crystallize).toContain('limited the work to read-only or no changes')
+        expect(crystallize).toContain('do not modify any artifact')
+    })
+
+    it('prioritizes explicit intent, then resumed work, then backlog priority', () => {
+        expect(session).toContain('user supplied an objective, it takes precedence')
+        expect(session).toContain('resume a `[/]` task')
+        expect(session).toContain('highest-priority `[ ]` task')
+    })
+
+    it('distinguishes complete, partial, and genuinely blocked work', () => {
+        for (const workflow of [task, crystallize]) {
+            expect(workflow).toContain('only if complete')
+            expect(workflow).toContain('unresolved dependency prevents progress')
+            expect(workflow).toContain('keep `[/]` for partial work')
+        }
+        expect(crystallize).toContain('Task: [x] / [/] / [!]')
+    })
+})
+
+// ---------------------------------------------------------------------------
+// 11. Workflow brevity — each must be concise enough for LLM working memory
 // ---------------------------------------------------------------------------
 describe('Workflow brevity', () => {
     const maxLines = 35 // allowing some margin over the 30-line target
@@ -163,4 +317,22 @@ describe('Workflow brevity', () => {
         const lines = body.trim().split('\n').length
         expect(lines).toBeLessThanOrEqual(maxLines)
     })
+
+    it(`issue.md is ≤${maxLines} lines (excluding frontmatter)`, () => {
+        const body = issue.replace(/^---[\s\S]*?---\n/, '')
+        const lines = body.trim().split('\n').length
+        expect(lines).toBeLessThanOrEqual(maxLines)
+    })
+
+    it(`reconcile.md is ≤${maxLines} lines (excluding frontmatter)`, () => {
+        const body = reconcile.replace(/^---[\s\S]*?---\n/, '')
+        const lines = body.trim().split('\n').length
+        expect(lines).toBeLessThanOrEqual(maxLines)
+    })
+
+    it(`adopt.md is ≤${maxLines} lines (excluding frontmatter)`, () => {
+        const body = adopt.replace(/^---[\s\S]*?---\n/, '')
+        const lines = body.trim().split('\n').length
+        expect(lines).toBeLessThanOrEqual(maxLines)
+    })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autonomos/core",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "description": "SDK and core definitions for the Agent Protocol",
   "type": "module",
   "types": "./dist/index.d.mts",