@urielsh/prodify 0.1.0

package/dist/skills/schema.js

@@ -0,0 +1,159 @@
+import { normalizeRepoRelativePath } from '../core/paths.js';
+import { ProdifyError } from '../core/errors.js';
+import { CONTRACT_STAGE_NAMES } from '../contracts/source-schema.js';
+const SKILL_CATEGORIES = ['stage-method', 'domain', 'quality-policy'];
+const REPO_CONTEXT_FACTS = ['language', 'framework', 'project_type', 'architecture_pattern', 'risk_signal'];
+function asString(value, fieldName) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new ProdifyError(`Skill field "${fieldName}" must be a non-empty string.`, {
+            code: 'SKILL_SCHEMA_INVALID'
+        });
+    }
+    return value.trim();
+}
+function asOptionalStringArray(value, fieldName) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return [];
+    }
+    return asStringArray(value, fieldName);
+}
+function asStringArray(value, fieldName) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new ProdifyError(`Skill field "${fieldName}" must be a non-empty list.`, {
+            code: 'SKILL_SCHEMA_INVALID'
+        });
+    }
+    const normalized = value.map((entry) => asString(entry, fieldName));
+    return [...new Set(normalized)].sort((left, right) => left.localeCompare(right));
+}
+function asRecord(value, fieldName) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new ProdifyError(`Skill field "${fieldName}" must be a mapping.`, {
+            code: 'SKILL_SCHEMA_INVALID'
+        });
+    }
+    return value;
+}
+function asSkillCategory(value) {
+    const category = asString(value, 'category');
+    if (!SKILL_CATEGORIES.includes(category)) {
+        throw new ProdifyError(`Skill category is invalid: ${category}.`, {
+            code: 'SKILL_SCHEMA_INVALID'
+        });
+    }
+    return category;
+}
+function asStageList(value, fieldName) {
+    const stages = asStringArray(value, fieldName);
+    for (const stage of stages) {
+        if (!CONTRACT_STAGE_NAMES.includes(stage)) {
+            throw new ProdifyError(`Skill field "${fieldName}" contains unsupported stage "${stage}".`, {
+                code: 'SKILL_SCHEMA_INVALID'
+            });
+        }
+    }
+    return stages;
+}
+function normalizePredicate(value, fieldName) {
+    const record = asRecord(value, fieldName);
+    const fact = asString(record.fact, `${fieldName}.fact`);
+    if (!REPO_CONTEXT_FACTS.includes(fact)) {
+        throw new ProdifyError(`Skill condition fact is invalid: ${fact}.`, {
+            code: 'SKILL_SCHEMA_INVALID'
+        });
+    }
+    return {
+        fact,
+        includes: asString(record.includes, `${fieldName}.includes`)
+    };
+}
+export function normalizeSkillCondition(value, fieldName) {
+    const record = asRecord(value, fieldName);
+    const all = Array.isArray(record.all)
+        ? record.all.map((entry, index) => normalizePredicate(entry, `${fieldName}.all[${index}]`))
+        : [];
+    if (all.length === 0) {
+        throw new ProdifyError(`Skill condition "${fieldName}" must declare at least one "all" predicate.`, {
+            code: 'SKILL_SCHEMA_INVALID'
+        });
+    }
+    return {
+        all: all.sort((left, right) => `${left.fact}:${left.includes}`.localeCompare(`${right.fact}:${right.includes}`))
+    };
+}
+export function validateSkillDefinitionShape(value) {
+    const record = asRecord(value, 'skill');
+    return {
+        schema_version: asString(record.schema_version, 'schema_version'),
+        id: asString(record.id, 'id'),
+        name: asString(record.name, 'name'),
+        version: asString(record.version, 'version'),
+        category: asSkillCategory(record.category),
+        description: asString(record.description, 'description'),
+        intended_use: asStringArray(record.intended_use, 'intended_use'),
+        stage_compatibility: asStageList(record.stage_compatibility, 'stage_compatibility'),
+        activation_conditions: Array.isArray(record.activation_conditions)
+            ? record.activation_conditions.map((entry, index) => normalizeSkillCondition(entry, `activation_conditions[${index}]`))
+            : [],
+        execution_guidance: asStringArray(record.execution_guidance, 'execution_guidance'),
+        caution_guidance: asOptionalStringArray(record.caution_guidance, 'caution_guidance')
+    };
+}
+export function validateSkillRegistryManifest(value) {
+    const record = asRecord(value, 'skill registry');
+    return {
+        schema_version: asString(record.schema_version, 'schema_version'),
+        skills: asStringArray(record.skills, 'skills')
+            .map((entry) => normalizeRepoRelativePath(entry))
+    };
+}
+function validateRoutingSkillIds(skillIds, fieldName) {
+    return [...new Set(skillIds.map((entry) => asString(entry, fieldName)))].sort((left, right) => left.localeCompare(right));
+}
+function normalizeRoutingRule(value, fieldName) {
+    const record = asRecord(value, fieldName);
+    return {
+        skill: asString(record.skill, `${fieldName}.skill`),
+        when: normalizeSkillCondition(record.when, `${fieldName}.when`),
+        reason: asString(record.reason, `${fieldName}.reason`)
+    };
+}
+export function normalizeStageSkillRouting(value) {
+    if (value === undefined || value === null) {
+        return {
+            default_skills: [],
+            allowed_skills: [],
+            conditional_skills: []
+        };
+    }
+    const record = asRecord(value, 'skill_routing');
+    const defaultSkills = Array.isArray(record.default_skills)
+        ? validateRoutingSkillIds(record.default_skills, 'skill_routing.default_skills')
+        : [];
+    const allowedSkills = Array.isArray(record.allowed_skills)
+        ? validateRoutingSkillIds(record.allowed_skills, 'skill_routing.allowed_skills')
+        : [];
+    const conditionalSkills = Array.isArray(record.conditional_skills)
+        ? record.conditional_skills.map((entry, index) => normalizeRoutingRule(entry, `skill_routing.conditional_skills[${index}]`))
+            .sort((left, right) => left.skill.localeCompare(right.skill) || left.reason.localeCompare(right.reason))
+        : [];
+    for (const skillId of defaultSkills) {
+        if (!allowedSkills.includes(skillId)) {
+            throw new ProdifyError(`Default skill "${skillId}" must also be listed in allowed_skills.`, {
+                code: 'SKILL_ROUTING_INVALID'
+            });
+        }
+    }
+    for (const rule of conditionalSkills) {
+        if (!allowedSkills.includes(rule.skill)) {
+            throw new ProdifyError(`Conditional skill "${rule.skill}" must also be listed in allowed_skills.`, {
+                code: 'SKILL_ROUTING_INVALID'
+            });
+        }
+    }
+    return {
+        default_skills: defaultSkills,
+        allowed_skills: allowedSkills,
+        conditional_skills: conditionalSkills
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/docs/canonical-prodify-layout.md

@@ -0,0 +1,87 @@
+# Canonical `.prodify/` Layout
+
+## Goal
+Define the current `.prodify`-first runtime layout and the boundary between generated product assets and repository-local self-hosted additions.
+
+## Canonical Directory Tree
+
+```text
+.prodify/
+  AGENTS.md
+  project.md
+  planning.md
+  version.json
+  runtime-commands.md
+  state.json
+  artifacts/
+    README.md
+    <stage outputs and repo-local artifacts>
+  contracts-src/
+    README.md
+    *.contract.md
+  contracts/
+    *.contract.json
+  metrics/
+    README.md
+  tasks/
+    README.md
+    *.md
+  rules/
+    README.md
+    *.md
+  templates/
+    README.md
+    *.template.md
+```
+
+Preset source files for Prodify itself live in the repository under `assets/presets/default/canonical/`. They are not copied into `.prodify/presets/` in the current product model.
+
+## Purpose Of Each Canonical Path
+
+| Path | Purpose | User Edited |
+| --- | --- | --- |
+| `.prodify/AGENTS.md` | Canonical cross-agent operating instructions and repository protocol source. | Yes |
+| `.prodify/project.md` | Human-readable project context, goals, scope, and conventions. | Yes |
+| `.prodify/planning.md` | Human-readable roadmap, milestones, and execution backlog. | Yes |
+| `.prodify/version.json` | Machine-readable preset version and schema version metadata. | Managed by Prodify upgrades |
+| `.prodify/runtime-commands.md` | Canonical runtime command reference for in-agent execution. | Yes |
+| `.prodify/state.json` | Durable runtime state for the agent-executed lifecycle. | Managed by runtime |
+| `.prodify/contracts-src/` | User-authored stage contract sources. | Yes |
+| `.prodify/contracts/` | Compiled runtime contracts consumed by validation and execution. | Managed by runtime |
+| `.prodify/artifacts/` | Runtime stage outputs plus repo-local self-hosted design artifacts. | Mixed |
+| `.prodify/metrics/` | Local baseline, final, and delta score artifacts. | Managed by runtime |
+| `.prodify/tasks/` | Canonical task library authored by the repository owner. | Yes |
+| `.prodify/rules/` | Canonical reusable rules referenced by tasks and generated outputs. | Yes |
+| `.prodify/templates/` | Canonical markdown templates that define required artifact shapes. | Yes |
+
+## Canonical vs Generated Split
+
+### Canonical Files
+- Live only under `.prodify/`.
+- Are the only product-owned files users should edit directly when working with Prodify-managed content.
+- Must remain agent-neutral unless a preset overlay explicitly defines agent-specific behavior.
+
+### Generated Compatibility Files
+- Are not part of the current default lifecycle.
+- If they exist in future or opt-in flows, they live outside `.prodify/` at agent-specific target paths.
+- Must always be reproducible from canonical sources plus deterministic generation rules.
+
+### Repository-Local Contributor Files
+- May live outside `.prodify/` in the Prodify source repository itself.
+- Are not product-owned runtime outputs.
+- Must be documented explicitly when their path could be mistaken for a generated compatibility file.
+
+## Root Cleanliness Rule
+- The repository root should remain free of Prodify-owned runtime files in the default lifecycle.
+- If the Prodify source repository keeps a root `AGENTS.md`, it must be treated as contributor-local guidance rather than a generated runtime file.
+- No shadow copies of canonical `.prodify/` content should be stored elsewhere in the repository.
+
+## Separation Principle
+- Canonical source content belongs in `.prodify/`.
+- Future compatibility outputs, if implemented, belong at agent-required target paths.
+- Generated files must never become a second source of truth.
+
+## Decision Summary
+- `.prodify/` is canonical.
+- The default supported flow does not require root-level generated agent files.
+- Repository-local contributor files must be labeled explicitly when they share those legacy paths.

package/docs/claude-support.md

@@ -0,0 +1,22 @@
+# Claude Support
+
+## Goal
+Define the current Claude bootstrap path and the still-planned compatibility-file surface.
+
+## Current Supported Behavior
+- Bootstrap path: `.prodify/AGENTS.md`
+- Root compatibility file: not part of the default lifecycle
+
+## Planned Compatibility Surface
+- Status: `planned`
+- Canonical source: `.prodify/AGENTS.md`
+- Future target path if enabled: `CLAUDE.md`
+
+## Direct Copy vs Transformation
+- Planned behavior: direct copy with generated header.
+- Future option: minor title normalization if Claude-specific naming proves useful.
+- No semantic reduction should occur unless a later design explicitly defines it.
+
+## Limitation
+- The bootstrap path is already `.prodify`-first.
+- The compatibility file remains design-only until explicitly implemented.

package/docs/cli-doctor-spec.md

@@ -0,0 +1,52 @@
+# `prodify doctor` Specification
+
+## Goal
+Define a health-check command for validating Prodify repository setup.
+
+## Required Checks
+
+### Canonical Presence
+- `.prodify/` exists
+- `.prodify/AGENTS.md` exists
+- `.prodify/project.md` exists
+- `.prodify/planning.md` exists
+- `.prodify/version.json` exists
+
+### Canonical Structure
+- `.prodify/tasks/`, `.prodify/rules/`, and `.prodify/templates/` exist
+- required starter README files exist when expected
+
+### Compatibility Surface
+- managed compatibility files exist where expected for installed or detected targets
+- managed-file headers are valid
+- generated files still map to known compatibility targets
+
+### Drift Detection
+- regenerate expected content in memory
+- compare it to each managed file
+- report drifted files without overwriting them
+
+## Output Format
+Doctor should report pass/fail lines grouped by category:
+- `canonical`
+- `compatibility`
+- `drift`
+
+Example shape:
+
+```text
+Prodify Doctor
+canonical: PASS
+compatibility/codex: PASS
+compatibility/copilot: SKIP
+drift/AGENTS.md: FAIL
+```
+
+## Exit Behavior
+- exit success when all required checks pass and optional checks do not fail
+- exit failure when canonical setup is missing, required generated files are invalid, or drift is detected on required managed files
+
+## Rules
+- `doctor` must not modify files
+- `doctor` must report verified findings only
+- `doctor` must distinguish `FAIL` from `SKIP`

package/docs/cli-init-spec.md

@@ -0,0 +1,70 @@
+# `prodify init` Specification
+
+## Goal
+Define exactly what `prodify init` creates when bootstrapping Prodify in a repository.
+
+## Command Contract
+- `prodify init` creates the canonical `.prodify/` structure.
+- It must not create compatibility files unless the user explicitly requests agent installation in a separate command.
+- It should be safe to run in an empty repository or an existing repository root.
+
+## Required Canonical Outputs
+
+### Files
+- `.prodify/AGENTS.md`
+- `.prodify/project.md`
+- `.prodify/planning.md`
+- `.prodify/version.json`
+
+### Directories
+- `.prodify/tasks/`
+- `.prodify/rules/`
+- `.prodify/templates/`
+- `.prodify/presets/`
+
+## Starter Contents
+
+### `.prodify/AGENTS.md`
+- Canonical repository operating instructions.
+- Neutral, agent-agnostic source content.
+- No generated-file header because it is canonical, not generated.
+
+### `.prodify/project.md`
+- Project name
+- Summary
+- Goals
+- Constraints
+- Team conventions
+
+### `.prodify/planning.md`
+- Current milestone
+- Backlog
+- Risks
+- Open decisions
+
+### `.prodify/tasks/`
+- `README.md` describing how canonical tasks are organized
+- no generated compatibility files
+
+### `.prodify/rules/`
+- `README.md` describing reusable repository rules
+- optional starter rule files if the chosen preset includes them
+
+### `.prodify/templates/`
+- `README.md` describing canonical artifact templates
+- starter markdown templates if the chosen preset includes them
+
+### `.prodify/version.json`
+- `schema_version`
+- `preset_name`
+- `preset_version`
+
+## Preset Behavior
+- `prodify init` installs the default preset into `.prodify/`.
+- The default preset defines the initial contents of the canonical files and folders.
+- Agent-specific compatibility files are not generated by `init`.
+
+## Failure Conditions
+- Stop if `.prodify/` already exists and the command is not explicitly allowed to merge.
+- Stop if the repository root cannot be resolved.
+- Stop if the selected preset is missing required canonical files.

package/docs/cli-install-agent-spec.md

@@ -0,0 +1,48 @@
+# `prodify setup-agent <target>` Specification
+
+## Goal
+Define how Prodify performs global, repo-neutral agent setup for a selected coding agent.
+
+## Supported Invocation Shape
+- `prodify setup-agent codex`
+- `prodify setup-agent claude`
+- `prodify setup-agent copilot`
+- `prodify setup-agent opencode`
+
+## Command Behavior
+1. Verify the selected agent target is known.
+2. Detect the global setup root outside any repository.
+3. Register or refresh global runtime command availability for the selected agent.
+4. Record the configured agent in global setup state.
+5. Print next-step guidance for repo initialization and in-agent runtime use.
+
+## Per-Agent Behavior
+
+### Codex
+- Global setup target: Codex runtime environment
+- Repo impact: none
+- Runtime commands exposed: `$prodify-init`, `$prodify-execute`, `$prodify-resume`
+
+### Claude
+- Global setup target: Claude runtime environment
+- Repo impact: none
+- Runtime commands exposed: `$prodify-init`, `$prodify-execute`, `$prodify-resume`
+
+### Copilot
+- Global setup target: Copilot runtime environment
+- Repo impact: none
+- Runtime commands exposed: `$prodify-init`, `$prodify-execute`, `$prodify-resume`
+
+### OpenCode
+- Global setup target: OpenCode runtime environment
+- Repo impact: none
+- Runtime commands exposed: `$prodify-init`, `$prodify-execute`, `$prodify-resume`
+
+## Canonical Safety Rule
+- `prodify setup-agent <target>` must not modify canonical `.prodify/` source files in any repository.
+- The command writes only to global setup state outside the repo.
+
+## Conflict Rules
+- Existing agent setup entry: may be refreshed.
+- Multiple configured agents must be allowed to coexist.
+- Unsupported target: stop with a clear status message rather than guess.

package/docs/cli-sync-spec.md

@@ -0,0 +1,40 @@
+# `prodify sync` Specification
+
+## Goal
+Define how Prodify regenerates managed compatibility files from canonical `.prodify/` sources.
+
+## Core Semantics
+- `prodify sync` reads canonical `.prodify/` files.
+- It regenerates managed compatibility files already installed in the repository.
+- It must be deterministic and idempotent.
+- It must report what changed.
+
+## Target Discovery
+- Default behavior: sync all files that are already recognized as Prodify-managed by their headers.
+- Optional behavior: `prodify sync --agent <target>` may regenerate a specific documented target.
+- Sync must not guess new targets that have never been installed unless the caller explicitly requests one.
+
+## Sync Flow
+1. Resolve repository root.
+2. Verify `.prodify/` exists.
+3. Detect managed generated files.
+4. Recompute expected content for each managed target.
+5. Compare expected vs existing content.
+6. Rewrite only files whose canonical output has changed.
+7. Report unchanged, updated, skipped, and failed targets.
+
+## Managed-File Rules
+- Only files with a valid Prodify header are eligible for automatic sync.
+- Unmanaged files must not be overwritten by plain `sync`.
+- Drifted managed files must follow the manual-edit conflict policy.
+
+## Reporting
+The command output should include:
+- repository root
+- targets inspected
+- targets updated
+- targets unchanged
+- targets skipped or blocked
+
+## Idempotency Rule
+- Re-running `prodify sync` with unchanged canonical inputs must produce no content changes and no meaningless diffs.

package/docs/codex-support.md

@@ -0,0 +1,24 @@
+# Codex Support
+
+## Goal
+Define the current Codex bootstrap path and keep any future compatibility-file mapping clearly out of the default lifecycle.
+
+## Current Supported Behavior
+- Status: `supported`
+- Bootstrap entrypoint: `.prodify/AGENTS.md`
+- Root `AGENTS.md` generation: not part of the default lifecycle
+
+## Current Rules
+- Tell Codex to read `.prodify/AGENTS.md`.
+- Keep runtime state and workflow assets under `.prodify/`.
+- Do not treat repository-root `AGENTS.md` as a product-managed output in the current flow.
+
+## Future Compatibility Surface
+- Historical or future compatibility mode could target repository-root `AGENTS.md`.
+- If that mode returns, it must be explicit and opt-in rather than part of `prodify init` or `prodify update`.
+- This repository's existing root `AGENTS.md` is contributor-local guidance for developing Prodify itself.
+
+## Why This Distinction Matters
+- Codex is supported today through the canonical `.prodify/AGENTS.md` bootstrap path.
+- Presenting root `AGENTS.md` generation as current behavior would contradict the tested `.prodify`-first lifecycle.
+- Any future compatibility-file design must remain subordinate to the canonical `.prodify` model.

package/docs/compatibility-targets.md

@@ -0,0 +1,59 @@
+# Compatibility Targets
+
+## Goal
+Describe possible compatibility-file targets without confusing them with the current default lifecycle.
+
+## Current Lifecycle
+- In the current supported flow, every agent bootstraps directly from `.prodify/AGENTS.md`.
+- `prodify init` and `prodify update` do not create root-level compatibility files.
+- The entries below are future or non-default compatibility surfaces only.
+
+## Compatibility Matrix
+
+| Agent | Agent Support | Current Bootstrap Path | Compatibility File Status | Target Path If Enabled | Notes |
+| --- | --- | --- | --- | --- | --- |
+| Codex | Supported | `.prodify/AGENTS.md` | Not enabled in default flow | `AGENTS.md` | Root `AGENTS.md` in this repo is contributor-local, not product-generated. |
+| Claude | Supported bootstrap path, compatibility target planned | `.prodify/AGENTS.md` | Planned | `CLAUDE.md` | Same canonical source, different future target path. |
+| Copilot | Supported bootstrap path, compatibility target planned | `.prodify/AGENTS.md` | Planned | `.github/copilot-instructions.md` | Would likely need a shorter transformed output. |
+| OpenCode | Supported bootstrap path, compatibility target experimental | `.prodify/AGENTS.md` | Experimental | `.opencode/AGENTS.md` | Target path remains provisional until validated. |
+
+## Default Behavior
+
+- Source of truth: `.prodify/AGENTS.md`
+- No compatibility file is required for the current supported flow.
+- Any future compatibility-file generation must remain explicit and opt-in.
+
+## Compatibility Surfaces
+
+### Codex
+- Agent support: `supported`
+- Current bootstrap path: `.prodify/AGENTS.md`
+- Compatibility-file status: not enabled in the default lifecycle
+- Future target path if enabled: `AGENTS.md`
+
+### Claude
+- Agent support: bootstrap path supported
+- Current bootstrap path: `.prodify/AGENTS.md`
+- Compatibility-file status: planned
+- Future target path if enabled: `CLAUDE.md`
+
+### Copilot
+- Agent support: bootstrap path supported
+- Current bootstrap path: `.prodify/AGENTS.md`
+- Compatibility-file status: planned
+- Future target path if enabled: `.github/copilot-instructions.md`
+
+### OpenCode
+- Agent support: bootstrap path supported
+- Current bootstrap path: `.prodify/AGENTS.md`
+- Compatibility-file status: experimental
+- Future target path if enabled: `.opencode/AGENTS.md`
+- Limitation: target path may change if the live integration contract differs
+
+## Rules
+- Every target path must be explicit.
+- Every target must trace back to canonical `.prodify/` source files.
+- Compatibility-file status controls non-default behavior:
+  - `not enabled in default flow`: described only as a scoped future or repo-local compatibility surface
+  - `planned`: documented but not implemented
+  - `experimental`: opt-in only, with limitations clearly reported

package/docs/copilot-support.md

@@ -0,0 +1,30 @@
+# Copilot Support
+
+## Goal
+Define the compatibility target for GitHub Copilot.
+
+## Compatibility Mapping
+- Status: `planned`
+- Canonical sources:
+  - `.prodify/AGENTS.md`
+  - `.prodify/project.md`
+- Generated target: `.github/copilot-instructions.md`
+
+## Generation Behavior
+- Generate `.github/copilot-instructions.md` from canonical Prodify sources.
+- Prepend the standard generated-file header for target `copilot`.
+- Transform the canonical material into a concise instruction file suitable for an editor-integrated assistant.
+
+## Transformation Rules
+- Keep repository rules, goals, and high-signal conventions.
+- Include concise project context from `.prodify/project.md`.
+- Remove low-signal runtime orchestration details that are only useful for the full Prodify executor.
+- Preserve deterministic section ordering.
+
+## Sync Behavior
+- `prodify sync` may update `.github/copilot-instructions.md` when it is Prodify-managed.
+- `prodify doctor` must validate path existence, header validity, and content drift.
+
+## Notes
+- The expected output path is `.github/copilot-instructions.md`.
+- If the transformation rules are incomplete, generation must stop instead of producing a vague or partial file.

package/docs/default-preset.md

@@ -0,0 +1,47 @@
+# Default Preset
+
+## Goal
+Define the first stable default preset for bootstrapping repositories with Prodify.
+
+## Required Canonical Contents
+The default preset must include:
+- `.prodify/AGENTS.md`
+- `.prodify/project.md`
+- `.prodify/planning.md`
+- starter tasks
+- starter rules
+- starter templates
+
+## Minimum Viable Default Contents
+
+### `.prodify/AGENTS.md`
+- baseline repository operating instructions
+- canonical source text for generated compatibility files
+
+### `.prodify/project.md`
+- project summary
+- goals
+- constraints
+- conventions
+
+### `.prodify/planning.md`
+- milestone list
+- backlog section
+- open decisions section
+
+### Starter Tasks
+- `README.md`
+- at least one example task or task schema description so users understand how canonical tasks should be authored
+
+### Starter Rules
+- `README.md`
+- a small set of baseline operating rules for generated instruction files
+
+### Starter Templates
+- `README.md`
+- at least one example markdown template showing how Prodify expects structured artifacts to look
+
+## Preset Intent
+- The default preset should be simple, stable, and agent-neutral.
+- It should be sufficient for `prodify init` to leave the repository ready for later compatibility generation.
+- It should not require generated compatibility files to exist immediately.