naive-framework 0.5.0 → 0.6.0

package/interface/layer.json

@@ -14,6 +14,10 @@
     {
       "id": "choosing-artifacts",
       "path": "interface/skills/choosing-artifacts/SKILL.md"
+    },
+    {
+      "id": "run-playbook",
+      "path": "interface/skills/run-playbook/SKILL.md"
     }
   ],
   "records": [

package/interface/skills/run-playbook/SKILL.md

@@ -0,0 +1,38 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, interface, playbooks, mentor]
+ai-model: claude-opus-5.5
+created: 2026-10-29T21:10:00Z
+source: hybrid
+name: run-playbook
+description: >
+  Walk a founder through a Naive playbook, one step at a time, as a mentor: hold
+  the conversation each step describes, write what is learned as drafts the
+  founder confirms, and build the view each step names. Start with Torian's
+  playbook when a founder has a fresh venture and does not know where to start.
+  MANDATORY TRIGGERS: where do I start, I have a venture now what, walk me
+  through, playbook, Torian's playbook, help me find my idea, what should I build.
+---
+
+# Run a playbook
+
+Interface layer. A playbook (`purpose/playbooks/<id>.json`, shape in `schema/playbook.schema.json`) is the order of the work; a template is the empty shape of one record. Each step names its goal, how to hold the conversation, the records it writes, when it is done and the view to build.
+
+## Which playbook
+
+- A fresh venture with no problem statement, or a founder who says they don't know where to start: `torians-playbook`. It starts with the founder, not the business.
+- Otherwise list `purpose/playbooks/` and pick the one whose `when` fits. Say which one you chose and why.
+
+## How to run it
+
+1. Read the playbook and the venture's state first (`naive setup state`, `naive phase`). Skip a step whose records are already confirmed, and say so.
+2. One step at a time. Tell the founder which step you are on and what it is for, in a sentence.
+3. Hold the conversation the step describes. Ask one question at a time. Use the founder's words; never put words in their mouth.
+4. Write what you learn to the step's routes through Naive (`mentura_write`, the router). Agent writes land as drafts or proposals; the founder confirms them. Never mark a decision decided.
+5. Build the step's view with the `choosing-artifacts` skill, from the records you just wrote, so the founder can read and correct it.
+6. The step is done when its `done_when` holds. Then move to the next one.
+7. If the founder wants to stop, stop. The records keep where you got to; the next session reads them and picks up.
+
+## Torian's playbook in short
+
+Know the founder (the puzzle of their life, after Aristotle: what they are for) → the problem that puzzle points at → the markets it lives in → the solutions that exist and how the founder feels about them → the founder decides whether to build. Dislike of every existing answer to a problem they care about is the start of a venture. Liking an existing answer is a reason to use it, not build it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naive-framework",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Naive, a venture development framework: conventions, routes, records, checks and an agent interface for building a venture.",
   "type": "module",
   "license": "MIT",

package/packages/customers/package.json

@@ -11,30 +11,58 @@
     "freshness"
   ],
   "layer": "purpose",
-  "records": ["customer", "data-stream"],
-  "schemas": ["schema/data-master.schema.json", "schema/stream.schema.json"],
+  "records": [
+    "customer",
+    "data-stream"
+  ],
+  "schemas": [
+    "schema/data-master.schema.json",
+    "schema/stream.schema.json"
+  ],
   "templates": [],
-  "checks": ["schema/check-data-packages.mjs"],
-  "skill": null,
+  "checks": [
+    "schema/check-data-packages.mjs"
+  ],
+  "skill": {
+    "id": "customers-function",
+    "path": "packages/customers/skill/SKILL.md"
+  },
   "use_model": [
     {
       "step": "stage",
       "kind": "choice",
       "for_each": "customers",
       "question": "Which buying stage do the notes {item.notes} put this customer at?",
-      "inputs": ["item.notes"],
-      "options": ["aware", "trying", "paying", "gone"],
+      "inputs": [
+        "item.notes"
+      ],
+      "options": [
+        "aware",
+        "trying",
+        "paying",
+        "gone"
+      ],
       "threshold": 0.7
     },
     {
       "step": "summary",
       "kind": "draft",
       "for_each": "customers",
-      "after": ["stage"],
+      "after": [
+        "stage"
+      ],
       "question": "Write one plain sentence about this customer from the notes {item.notes} and the stage {steps.stage}, with the seat count written as {{seats}}.",
-      "inputs": ["item.notes"],
-      "computed": { "seats": { "item": "seats" } },
-      "keep": ["seats"]
+      "inputs": [
+        "item.notes"
+      ],
+      "computed": {
+        "seats": {
+          "item": "seats"
+        }
+      },
+      "keep": [
+        "seats"
+      ]
     }
   ],
   "complete": false

package/packages/customers/skill/SKILL.md

@@ -0,0 +1,57 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, packages, customers, functions]
+ai-model: claude-opus-5.5
+created: 2026-10-29T20:45:00Z
+source: ai-generated
+name: customers-function
+description: >
+  Work with the customers function of a Naive venture in code: read
+  and write its records through the router or MCP, know what lands as a draft
+  and what needs a person, run its checks, and pick the artifact each action
+  builds. MANDATORY TRIGGERS: customer record, CRM, customer list, customer activity, who are our customers.
+---
+
+# Customers function
+
+Package `packages/customers`. A venture function is a part of the venture with one accountable owner. The owner is named in `venture.json` under `functions` and in `naive.config.json`. Master data for customers: one `[id].json` each, plus append-only activity in `_streams/`. Never complete. When a CRM is the system of record, records are pointers and summaries.
+
+## Records
+
+| Route | What it is | Record type |
+|---|---|---|
+| `customers` | List of customer master records | `customer` |
+| `customers/[id]` | One customer master record | `customer` |
+| `purpose/data-stream/[id]` | Declares one append-only stream and whether it is sensitive | `data-stream` |
+
+The schemas are listed in `packages/customers/package.json`. Call `mentura_layout` with a route to get its schema, template, gate and what need-now says before you act.
+
+## Read and write
+
+- Over MCP: `mentura_read` with `venture` and `route` (for example `customers`). Pass `header_only` to see state and owner first. `mentura_write` with the whole `record`, and say what it came from and the decision it acts under.
+- In a shell inside the venture: `naive mcp` serves the same routes; `mentura routes` lists them.
+- Read through Naive, never from memory. A missing, draft or stale record is shown as such, never filled in.
+- Every write is checked against its schema and logged in `system/provenance`.
+
+## Draft or person
+
+Customer records have no escalating class, so an agent's write is the record, logged in provenance. Streams are append-only: add lines, never rewrite them. A sensitive stream stays out of model context; read its summary. If `knowledge/sources.json` names a CRM, write a pointer, not a copy.
+
+Open decisions for this function come from `mentura_decisions`. Propose with `mentura_propose_decision`; you never mark a decision decided.
+
+## Checks
+
+`naive check` runs every check that applies to the venture. For this function: `schema/check-data-packages.mjs`: coverage and freshness, not completeness. Run it after each write, and fix a failure before you report the work done.
+
+## Actions and artifacts
+
+Build artifacts by the `choosing-artifacts` skill (`interface/skills/choosing-artifacts/SKILL.md`). Each artifact names the records it was built from.
+
+| Action | Artifact | Built from |
+|---|---|---|
+| Review accounts | Dashboard | customers/ |
+| Prepare for a customer call | Document | customers/[id] and its stream |
+
+## Depends on
+
+Feeds validation evidence (interviews, retention) and marketing audiences. Reads nothing it does not own.

package/packages/finance/package.json

@@ -43,6 +43,9 @@
   "schemas": [],
   "templates": [],
   "checks": [],
-  "skill": null,
+  "skill": {
+    "id": "finance-function",
+    "path": "packages/finance/skill/SKILL.md"
+  },
   "use_model": []
 }

package/packages/finance/skill/SKILL.md

@@ -0,0 +1,57 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, packages, finance, functions]
+ai-model: claude-opus-5.5
+created: 2026-10-29T20:45:00Z
+source: ai-generated
+name: finance-function
+description: >
+  Work with the finance function of a Naive venture in code: read
+  and write its records through the router or MCP, know what lands as a draft
+  and what needs a person, run its checks, and pick the artifact each action
+  builds. MANDATORY TRIGGERS: business model, pricing, budget, runway, how do we make money, unit economics.
+---
+
+# Finance function
+
+Package `packages/finance`. A venture function is a part of the venture with one accountable owner. The owner is named in `venture.json` under `functions` and in `naive.config.json`. How the venture makes and spends money: business models, pricing, budget and runway.
+
+## Records
+
+| Route | What it is | Record type |
+|---|---|---|
+| `business-models` | The business models the venture uses (a system record from `schema/vocab/business-models.json`; no route of its own yet, so read it through `mentura_layout`) | `business-models` |
+| `validation/pricing` | Price model, points, buyer and evidence they pay (owned by validation, read here) | `validation-pricing` |
+| `purpose/money/summary` | Cash, monthly flows and runway (owned by money, read here) | `money-summary` |
+
+The schemas are listed in `packages/finance/package.json`. Call `mentura_layout` with a route to get its schema, template, gate and what need-now says before you act.
+
+## Read and write
+
+- Over MCP: `mentura_read` with `venture` and `route` (for example `business-models`). Pass `header_only` to see state and owner first. `mentura_write` with the whole `record`, and say what it came from and the decision it acts under.
+- In a shell inside the venture: `naive mcp` serves the same routes; `mentura routes` lists them.
+- Read through Naive, never from memory. A missing, draft or stale record is shown as such, never filled in.
+- Every write is checked against its schema and logged in `system/provenance`.
+
+## Draft or person
+
+Finance has no record of its own that an agent may settle. Pricing changes go through validation; money facts come from the money source. Propose a budget or model with `mentura_propose_decision`; a person decides.
+
+Open decisions for this function come from `mentura_decisions`. Propose with `mentura_propose_decision`; you never mark a decision decided.
+
+## Checks
+
+`naive check` runs every check that applies to the venture. For this function: No checks of its own yet. `naive check` covers the records it reads (validation and money checks). Run it after each write, and fix a failure before you report the work done.
+
+## Actions and artifacts
+
+Build artifacts by the `choosing-artifacts` skill (`interface/skills/choosing-artifacts/SKILL.md`). Each artifact names the records it was built from.
+
+| Action | Artifact | Built from |
+|---|---|---|
+| Show runway, burn, revenue | Dashboard | money/ and purpose/money/summary |
+| Build a model or budget | File (.xlsx) when asked, else dashboard | money/, validation/pricing |
+
+## Depends on
+
+Reads `validation/pricing` and `product`. Owns money master data through its owner: an agent's money write goes to the finance owner first (money's gate rule).

package/packages/foundation/package.json

@@ -47,7 +47,10 @@
     "schema/check-validation.mjs",
     "schema/foundation.mjs"
   ],
-  "skill": null,
+  "skill": {
+    "id": "foundation-function",
+    "path": "packages/foundation/skill/SKILL.md"
+  },
   "use_model": [],
   "use_cache": [
     {

package/packages/foundation/skill/SKILL.md

@@ -0,0 +1,60 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, packages, foundation, functions]
+ai-model: claude-opus-5.5
+created: 2026-10-29T20:45:00Z
+source: ai-generated
+name: foundation-function
+description: >
+  Work with the foundation function of a Naive venture in code: read
+  and write its records through the router or MCP, know what lands as a draft
+  and what needs a person, run its checks, and pick the artifact each action
+  builds. MANDATORY TRIGGERS: our problem statement, who is our customer, ICP, telos, why do we exist, principles, alignment, strategic foundation.
+---
+
+# Foundation function
+
+Package `packages/foundation`. A venture function is a part of the venture with one accountable owner. The owner is named in `venture.json` under `functions` and in `naive.config.json`. What the venture is, why, for whom and with what. Every other function reads these records, so they change rarely and only by a person.
+
+## Records
+
+| Route | What it is | Record type |
+|---|---|---|
+| `foundation/problem` | The problem claim and its graded evidence | `validation-problem` |
+| `foundation/icp` | Who the venture serves; one primary profile | `icp` |
+| `foundation/telos` | The end the venture exists to reach, with exit criteria per phase | `telos` |
+| `foundation/alignment` | How products and agents must behave | `alignment` |
+| `knowledge/venture-profile` | The story and thesis in prose (read only) | `venture-profile` |
+| `purpose/foundation` | Command: the Five Ws and How, each confirmed, drafted, waiting or missing | command or item |
+
+The schemas are listed in `packages/foundation/package.json`. Call `mentura_layout` with a route to get its schema, template, gate and what need-now says before you act.
+
+## Read and write
+
+- Over MCP: `mentura_read` with `venture` and `route` (for example `foundation/problem`). Pass `header_only` to see state and owner first. `mentura_write` with the whole `record`, and say what it came from and the decision it acts under.
+- In a shell inside the venture: `naive mcp` serves the same routes; `mentura routes` lists them.
+- Read through Naive, never from memory. A missing, draft or stale record is shown as such, never filled in.
+- Every write is checked against its schema and logged in `system/provenance`.
+
+## Draft or person
+
+All four foundation records carry the strategy-or-constitution decision class. An agent's write always lands as a draft in `_drafts/`. Only the founder accepts it. Never present a draft as the founder's words.
+
+Open decisions for this function come from `mentura_decisions`. Propose with `mentura_propose_decision`; you never mark a decision decided.
+
+## Checks
+
+`naive check` runs every check that applies to the venture. For this function: `schema/check-telos.mjs`, `schema/check-validation.mjs`, `schema/foundation.mjs` and the schema checks (`schema/validate.py`). Run it after each write, and fix a failure before you report the work done.
+
+## Actions and artifacts
+
+Build artifacts by the `choosing-artifacts` skill (`interface/skills/choosing-artifacts/SKILL.md`). Each artifact names the records it was built from.
+
+| Action | Artifact | Built from |
+|---|---|---|
+| Review the strategic foundation | Document (brief) | foundation/*, the phase in venture.json |
+| Decide pending decisions | Page that collects answers (the docket) | decisions/ |
+
+## Depends on
+
+Reads `product` (which product the foundation is about). Read by every other function: validation, product, marketing, people, finance and the handoffs. A change here marks dependents stale; run `system/revalidate` with `tag:foundation/icp` (or the route you changed).

package/packages/investors/package.json

@@ -11,11 +11,20 @@
     "freshness"
   ],
   "layer": "purpose",
-  "records": ["investor"],
-  "schemas": ["schema/data-master.schema.json"],
+  "records": [
+    "investor"
+  ],
+  "schemas": [
+    "schema/data-master.schema.json"
+  ],
   "templates": [],
-  "checks": ["schema/check-data-packages.mjs"],
-  "skill": null,
+  "checks": [
+    "schema/check-data-packages.mjs"
+  ],
+  "skill": {
+    "id": "investors-function",
+    "path": "packages/investors/skill/SKILL.md"
+  },
   "use_model": [],
   "complete": false
 }

package/packages/investors/skill/SKILL.md

@@ -0,0 +1,57 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, packages, investors, functions]
+ai-model: claude-opus-5.5
+created: 2026-10-29T20:45:00Z
+source: ai-generated
+name: investors-function
+description: >
+  Work with the investors function of a Naive venture in code: read
+  and write its records through the router or MCP, know what lands as a draft
+  and what needs a person, run its checks, and pick the artifact each action
+  builds. MANDATORY TRIGGERS: investor list, fundraising pipeline, investor update, who has invested, cap table contacts.
+---
+
+# Investors function
+
+Package `packages/investors`. A venture function is a part of the venture with one accountable owner. The owner is named in `venture.json` under `functions` and in `naive.config.json`. Master data for investors: one `[id].json` each, plus append-only activity in `_streams/`. Never complete.
+
+## Records
+
+| Route | What it is | Record type |
+|---|---|---|
+| `investors` | List of investor master records | `investor` |
+| `investors/[id]` | One investor master record | `investor` |
+| `purpose/data-stream/[id]` | The investor activity streams | `data-stream` |
+
+The schemas are listed in `packages/investors/package.json`. Call `mentura_layout` with a route to get its schema, template, gate and what need-now says before you act.
+
+## Read and write
+
+- Over MCP: `mentura_read` with `venture` and `route` (for example `investors`). Pass `header_only` to see state and owner first. `mentura_write` with the whole `record`, and say what it came from and the decision it acts under.
+- In a shell inside the venture: `naive mcp` serves the same routes; `mentura routes` lists them.
+- Read through Naive, never from memory. A missing, draft or stale record is shown as such, never filled in.
+- Every write is checked against its schema and logged in `system/provenance`.
+
+## Draft or person
+
+Investor records have no escalating class, so an agent's write is the record, logged in provenance. Terms and ownership live in `governance/ownership`, which a person decides; never record a commitment here that the cap table does not show.
+
+Open decisions for this function come from `mentura_decisions`. Propose with `mentura_propose_decision`; you never mark a decision decided.
+
+## Checks
+
+`naive check` runs every check that applies to the venture. For this function: `schema/check-data-packages.mjs`: coverage and freshness. Run it after each write, and fix a failure before you report the work done.
+
+## Actions and artifacts
+
+Build artifacts by the `choosing-artifacts` skill (`interface/skills/choosing-artifacts/SKILL.md`). Each artifact names the records it was built from.
+
+| Action | Artifact | Built from |
+|---|---|---|
+| Pitch or investor update | Deck | foundation/, evidence/ (traction) and purpose/money/summary |
+| Track the raise | Dashboard | investors/ |
+
+## Depends on
+
+Reads foundation, evidence and money summaries for updates. Feeds the investor handoff and `governance/ownership`.

package/packages/marketing/package.json

@@ -58,6 +58,9 @@
     "schema/check-brand.mjs",
     "schema/check-assets.mjs"
   ],
-  "skill": null,
+  "skill": {
+    "id": "marketing-function",
+    "path": "packages/marketing/skill/SKILL.md"
+  },
   "use_model": []
 }

package/packages/marketing/skill/SKILL.md

@@ -0,0 +1,61 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, packages, marketing, functions]
+ai-model: claude-opus-5.5
+created: 2026-10-29T20:45:00Z
+source: ai-generated
+name: marketing-function
+description: >
+  Work with the marketing function of a Naive venture in code: read
+  and write its records through the router or MCP, know what lands as a draft
+  and what needs a person, run its checks, and pick the artifact each action
+  builds. MANDATORY TRIGGERS: sitemap, landing page, brand, voice, public content, marketing site, ads, campaigns.
+---
+
+# Marketing function
+
+Package `packages/marketing`. A venture function is a part of the venture with one accountable owner. The owner is named in `venture.json` under `functions` and in `naive.config.json`. Who the site and campaigns speak to, what goes where and why, the brand, the public variants and the pipeline.
+
+## Records
+
+| Route | What it is | Record type |
+|---|---|---|
+| `marketing/sitemap` | The planned public site, page by page | `marketing-sitemap` |
+| `marketing/content` | Public variants of internal records, as MDX (read through the router; write the files) | `marketing-content` |
+| `marketing/brand` | Brand tokens, type, voice and marks | `marketing-brand` |
+| `marketing/brand/tokens` | Command: the brand as design tokens and CSS | command or item |
+| `marketing/voice` | Command: content held to the voice rules | command or item |
+| `operations/marketing/public` | Command: the public gate | command or item |
+
+The schemas are listed in `packages/marketing/package.json`. Call `mentura_layout` with a route to get its schema, template, gate and what need-now says before you act.
+
+## Read and write
+
+- Over MCP: `mentura_read` with `venture` and `route` (for example `marketing/sitemap`). Pass `header_only` to see state and owner first. `mentura_write` with the whole `record`, and say what it came from and the decision it acts under.
+- In a shell inside the venture: `naive mcp` serves the same routes; `mentura routes` lists them.
+- Read through Naive, never from memory. A missing, draft or stale record is shown as such, never filled in.
+- Every write is checked against its schema and logged in `system/provenance`.
+
+## Draft or person
+
+`marketing/brand` carries the experience-design decision class, so an agent's write is a draft a person accepts. Every content file passes the public gate: it names its internal record and audience, and a published file needs a person's approval. Never mark content published yourself.
+
+Open decisions for this function come from `mentura_decisions`. Propose with `mentura_propose_decision`; you never mark a decision decided.
+
+## Checks
+
+`naive check` runs every check that applies to the venture. For this function: `schema/check-brand.mjs`, `schema/check-assets.mjs` and the public gate (`operations/marketing/public`). Run it after each write, and fix a failure before you report the work done.
+
+## Actions and artifacts
+
+Build artifacts by the `choosing-artifacts` skill (`interface/skills/choosing-artifacts/SKILL.md`). Each artifact names the records it was built from.
+
+| Action | Artifact | Built from |
+|---|---|---|
+| Draft a landing page or ad | Design | marketing/brand and positioning |
+| Set up the brand | Design system | marketing/brand |
+| Plan content | Document | marketing/sitemap and content records |
+
+## Depends on
+
+Reads `foundation/icp` and `product`. Hands the sitemap and brand to engineering. Publishes only under `governance/publication-policy`.

package/packages/money/package.json

@@ -36,7 +36,10 @@
   "checks": [
     "schema/check-data-packages.mjs"
   ],
-  "skill": null,
+  "skill": {
+    "id": "money-function",
+    "path": "packages/money/skill/SKILL.md"
+  },
   "use_model": [],
   "complete": false
 }

package/packages/money/skill/SKILL.md

@@ -0,0 +1,57 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, packages, money, functions]
+ai-model: claude-opus-5.5
+created: 2026-10-29T20:45:00Z
+source: ai-generated
+name: money-function
+description: >
+  Work with the money function of a Naive venture in code: read
+  and write its records through the router or MCP, know what lands as a draft
+  and what needs a person, run its checks, and pick the artifact each action
+  builds. MANDATORY TRIGGERS: bank account, cash, burn, runway numbers, transactions, money summary.
+---
+
+# Money function
+
+Package `packages/money`. A venture function is a part of the venture with one accountable owner. The owner is named in `venture.json` under `functions` and in `naive.config.json`. Master data for money: one `[id].json` per account, plus append-only activity in `_streams/`. When a bank or spend tool is the system of record, records are pointers and summaries.
+
+## Records
+
+| Route | What it is | Record type |
+|---|---|---|
+| `money` | List of money accounts | `money-account` |
+| `money/[id]` | One money account | `money-account` |
+| `purpose/money/summary` | Cash, monthly flows and runway from the last sync; the only money record a model sees | `money-summary` |
+
+The schemas are listed in `packages/money/package.json`. Call `mentura_layout` with a route to get its schema, template, gate and what need-now says before you act.
+
+## Read and write
+
+- Over MCP: `mentura_read` with `venture` and `route` (for example `money`). Pass `header_only` to see state and owner first. `mentura_write` with the whole `record`, and say what it came from and the decision it acts under.
+- In a shell inside the venture: `naive mcp` serves the same routes; `mentura routes` lists them.
+- Read through Naive, never from memory. A missing, draft or stale record is shown as such, never filled in.
+- Every write is checked against its schema and logged in `system/provenance`.
+
+## Draft or person
+
+The gate rule `money-to-finance`: money master data an agent writes goes to the finance function's owner before it is the record. Read `purpose/money/summary`, never raw transactions. Never move money or enter account numbers.
+
+Open decisions for this function come from `mentura_decisions`. Propose with `mentura_propose_decision`; you never mark a decision decided.
+
+## Checks
+
+`naive check` runs every check that applies to the venture. For this function: `schema/check-data-packages.mjs`: coverage and freshness. Run it after each write, and fix a failure before you report the work done.
+
+## Actions and artifacts
+
+Build artifacts by the `choosing-artifacts` skill (`interface/skills/choosing-artifacts/SKILL.md`). Each artifact names the records it was built from.
+
+| Action | Artifact | Built from |
+|---|---|---|
+| Show runway, burn, revenue | Dashboard | purpose/money/summary |
+| Build a model or budget | File (.xlsx) when asked, else dashboard | purpose/money/summary and validation/pricing |
+
+## Depends on
+
+Read by finance and investors. Its owner is the finance function's owner.

package/packages/people/package.json

@@ -59,6 +59,9 @@
     "schema/check-governance.mjs",
     "schema/check-team.mjs"
   ],
-  "skill": null,
+  "skill": {
+    "id": "people-function",
+    "path": "packages/people/skill/SKILL.md"
+  },
   "use_model": []
 }

package/packages/people/skill/SKILL.md

@@ -0,0 +1,59 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, packages, people, functions]
+ai-model: claude-opus-5.5
+created: 2026-10-29T20:45:00Z
+source: ai-generated
+name: people-function
+description: >
+  Work with the people function of a Naive venture in code: read
+  and write its records through the router or MCP, know what lands as a draft
+  and what needs a person, run its checks, and pick the artifact each action
+  builds. MANDATORY TRIGGERS: team, cofounder, hire, team plan, founder agreement, who owns what, hats, roles.
+---
+
+# People function
+
+Package `packages/people`. A venture function is a part of the venture with one accountable owner. The owner is named in `venture.json` under `functions` and in `naive.config.json`. Who the venture needs, what each person brings and on what terms people join.
+
+## Records
+
+| Route | What it is | Record type |
+|---|---|---|
+| `people` | Each person's role and hats | `people` |
+| `people/founders/[id]` | One file per founder | command or item |
+| `people/team` | Validation sub-score: skills needed, held and the gaps | `validation-team` |
+| `people/team-plan` | Who the venture needs, agent or person, when and with what authority | `team-plan` |
+| `governance/founder-agreement` | Roles, commitment, IP, departure, deadlock | `founder-agreement` |
+
+The schemas are listed in `packages/people/package.json`. Call `mentura_layout` with a route to get its schema, template, gate and what need-now says before you act.
+
+## Read and write
+
+- Over MCP: `mentura_read` with `venture` and `route` (for example `people`). Pass `header_only` to see state and owner first. `mentura_write` with the whole `record`, and say what it came from and the decision it acts under.
+- In a shell inside the venture: `naive mcp` serves the same routes; `mentura routes` lists them.
+- Read through Naive, never from memory. A missing, draft or stale record is shown as such, never filled in.
+- Every write is checked against its schema and logged in `system/provenance`.
+
+## Draft or person
+
+The founder agreement carries the ownership-or-control decision class: an agent's write is always a draft, and only the founders accept it. Never fill in equity, vesting or departure terms. The team plan sets who may read and write which routes (`system/robots`), so treat a change to it as a person's decision.
+
+Open decisions for this function come from `mentura_decisions`. Propose with `mentura_propose_decision`; you never mark a decision decided.
+
+## Checks
+
+`naive check` runs every check that applies to the venture. For this function: `schema/check-validation.mjs` (team), `schema/check-governance.mjs` and `schema/check-team.mjs`. Run it after each write, and fix a failure before you report the work done.
+
+## Actions and artifacts
+
+Build artifacts by the `choosing-artifacts` skill (`interface/skills/choosing-artifacts/SKILL.md`). Each artifact names the records it was built from.
+
+| Action | Artifact | Built from |
+|---|---|---|
+| Plan the team or a hire | Document | people/team-plan, people/team |
+| Show who owns which function | Page with a diagram | people, venture.json functions |
+
+## Depends on
+
+Read by the cofounder and counsel handoffs. Function owners in venture.json and `naive.config.json` come from here, and every gate that names an owner depends on it.

package/packages/product/package.json

@@ -44,6 +44,9 @@
   "checks": [
     "schema/check-ventures.mjs"
   ],
-  "skill": null,
+  "skill": {
+    "id": "product-function",
+    "path": "packages/product/skill/SKILL.md"
+  },
   "use_model": []
 }

package/packages/product/skill/SKILL.md

@@ -0,0 +1,59 @@
+---
+type: knowledge
+tags: [everything-ecosystem, naive, skills, packages, product, functions]
+ai-model: claude-opus-5.5
+created: 2026-10-29T20:45:00Z
+source: ai-generated
+name: product-function
+description: >
+  Work with the product function of a Naive venture in code: read
+  and write its records through the router or MCP, know what lands as a draft
+  and what needs a person, run its checks, and pick the artifact each action
+  builds. MANDATORY TRIGGERS: product card, what do we offer, flagship, wedge, substrate, spec, roadmap, product anatomy.
+---
+
+# Product function
+
+Package `packages/product`. A venture function is a part of the venture with one accountable owner. The owner is named in `venture.json` under `functions` and in `naive.config.json`. What the venture offers, each product's role (flagship, substrate, wedge) and to whom.
+
+## Records
+
+| Route | What it is | Record type |
+|---|---|---|
+| `product` | List of product cards | `product` |
+| `product/[id]` | One product card | `product` |
+| `product/anatomy-answers` | Product Anatomy scores per question (read only) | `anatomy-answers` |
+| `product/anatomy/[id]` | Product Anatomy input for one product (read only) | command or item |
+
+The schemas are listed in `packages/product/package.json`. Call `mentura_layout` with a route to get its schema, template, gate and what need-now says before you act.
+
+## Read and write
+
+- Over MCP: `mentura_read` with `venture` and `route` (for example `product`). Pass `header_only` to see state and owner first. `mentura_write` with the whole `record`, and say what it came from and the decision it acts under.
+- In a shell inside the venture: `naive mcp` serves the same routes; `mentura routes` lists them.
+- Read through Naive, never from memory. A missing, draft or stale record is shown as such, never filled in.
+- Every write is checked against its schema and logged in `system/provenance`.
+
+## Draft or person
+
+Product cards have no escalating decision class, so an agent's write is the record, logged in provenance. The package still gates completion: a person must confirm every required record before the engineering handoff opens. Specs and roadmap are planned, not records yet; write them as proposals.
+
+Open decisions for this function come from `mentura_decisions`. Propose with `mentura_propose_decision`; you never mark a decision decided.
+
+## Checks
+
+`naive check` runs every check that applies to the venture. For this function: `schema/check-ventures.mjs` and the product schema (`schema/product.schema.json`). The `check` action on `product/[id]` runs it for one card. Run it after each write, and fix a failure before you report the work done.
+
+## Actions and artifacts
+
+Build artifacts by the `choosing-artifacts` skill (`interface/skills/choosing-artifacts/SKILL.md`). Each artifact names the records it was built from.
+
+| Action | Artifact | Built from |
+|---|---|---|
+| Write a spec or roadmap | Document | product/ and decisions/ |
+| Show a flow or architecture | Page with a diagram | product/ |
+| Prototype a screen | Design | product specs |
+
+## Depends on
+
+Reads `foundation/icp`. Read by foundation, validation, marketing and finance. Unlocks the engineering handoff: build what is specified.

package/purpose/layer.json

@@ -29,7 +29,8 @@
     "idea-dump",
     "idea-map",
     "idea-map-conventions",
-    "idea-graph"
+    "idea-graph",
+    "playbook"
   ],
   "reads": [
     "venture",

package/purpose/playbooks/torians-playbook.json

@@ -0,0 +1,80 @@
+{
+  "id": "torians-playbook",
+  "title": "Torian's playbook: from your life's puzzle to a venture",
+  "purpose": "A founder with a fresh venture and no idea where to start ends with a founder profile, a problem their life points at, the markets around it, what already solves it and how they feel about that: the start of a venture worth building.",
+  "when": "Offer it right after create-venture when the founder has no problem statement yet, or says they don't know where to start.",
+  "function": "foundation",
+  "phase": "discovery",
+  "sources": ["Aristotle, Nicomachean Ethics: the good life as the work a person is for (ergon) and its end (telos)", "Mentorship as questions, not answers"],
+  "steps": [
+    {
+      "id": "know-the-founder",
+      "title": "Get to know the founder",
+      "goal": "The puzzle of the founder's life: what they keep turning over, what they are passionate about, what they are for, what they want to become.",
+      "conversation": [
+        "Act as a mentor, not an interviewer. Ask one question at a time and follow what they say.",
+        "Start with their life, not with business: what problem have you kept coming back to for years? What do people come to you for? What makes you angry about how things are done?",
+        "Ask what a good life looks like for them in ten years, and what they would do if money were settled.",
+        "Reflect back the pattern you hear in their own words, and ask whether you have it right. Never name their passion for them.",
+        "Keep it in the founder's words. Do not judge whether it could be a business yet."
+      ],
+      "writes": [{ "route": "people/founders/[id]", "as": "draft", "note": "the profile: puzzles, passions, telos, ambitions, strengths, values" }],
+      "done_when": "The founder confirms their profile reads true.",
+      "artifact": "Document: the founder profile, for them to correct"
+    },
+    {
+      "id": "find-the-problem",
+      "title": "Find the problem their puzzle points at",
+      "goal": "A real problem in the world that the founder's puzzle is oriented towards, and who has it.",
+      "conversation": [
+        "From the profile, ask who else lives with the puzzle they described, and what it costs those people.",
+        "Push for a specific person and a specific moment: who, when, what goes wrong, what they do today instead.",
+        "Separate the founder's own pain from other people's: is this a problem many people have, or one person's?",
+        "Name what is still a guess. A problem is a hypothesis until evidence backs it."
+      ],
+      "writes": [{ "route": "foundation/problem", "as": "draft" }],
+      "done_when": "The founder confirms a problem statement with a segment and at least one piece of evidence or a plan to get it.",
+      "artifact": "Document: the problem statement"
+    },
+    {
+      "id": "map-the-markets",
+      "title": "Map the markets they are drawn to",
+      "goal": "The markets where that problem lives, and which ones the founder is drawn to.",
+      "conversation": [
+        "List the places the problem shows up (industries, kinds of customers, settings) and ask which ones the founder cares about and why.",
+        "Look things up rather than guess, and bring back sources. Research comes back as evidence, not fact.",
+        "Note which markets the founder has an unfair advantage in: access, knowledge, people they know."
+      ],
+      "writes": [{ "route": "evidence/[id]", "as": "evidence", "note": "one record per market looked at, with its sources" }],
+      "done_when": "The founder has picked one or two markets to look at first.",
+      "artifact": "Page with a diagram: the problem and the markets around it"
+    },
+    {
+      "id": "meet-the-solutions",
+      "title": "Meet the solutions that already exist",
+      "goal": "What already solves the problem in those markets, and how the founder feels about each one. This is competitive research the founder lives through.",
+      "conversation": [
+        "Find the existing solutions, including the workarounds people use today, and show each with its source.",
+        "Ask how the founder feels about each one, not what they think of it as a business: would they use it, recommend it, be proud to have made it?",
+        "Listen for dissatisfaction. A founder who dislikes every existing answer to a problem they care about has found the start of a venture.",
+        "If an existing solution is good and they like it, say so. That is a reason to join or use it, not to build."
+      ],
+      "writes": [{ "route": "evidence/[id]", "as": "evidence", "note": "each solution, with sources and the founder's reaction" }],
+      "done_when": "Every solution the founder named has their reaction recorded.",
+      "artifact": "Document: the solutions and the founder's reactions, side by side"
+    },
+    {
+      "id": "decide-to-build",
+      "title": "Decide whether this is a venture",
+      "goal": "The founder's own decision: build a better answer to this problem, look further, or stop.",
+      "conversation": [
+        "Lay out what was learned: the puzzle, the problem, the markets, the solutions and how they felt.",
+        "Ask the founder to decide. Propose the decision with the options; never make it.",
+        "If they choose to build, the next playbook is validation: test the problem with the people who have it."
+      ],
+      "writes": [{ "route": "decisions/[id]", "as": "decision", "note": "build, keep looking, or stop; open until the founder decides" }],
+      "done_when": "The founder has decided.",
+      "artifact": "Page that collects the decision (the docket)"
+    }
+  ]
+}

package/schema/data-model.json

@@ -369,6 +369,16 @@
       ],
       "note": "Phases, gates and questions of Product Anatomy; self-describing, checked by its runner's tests"
     },
+    {
+      "id": "playbook",
+      "layer": "purpose",
+      "level": "method",
+      "schema": "schema/playbook.schema.json",
+      "paths": [
+        "purpose/playbooks/*.json"
+      ],
+      "note": "A step-by-step guide a venture function runs in conversation with the founder; run by interface/skills/run-playbook (a template is one record's empty shape; a playbook is the order of the work)"
+    },
     {
       "id": "idea-map-conventions",
       "layer": "purpose",

package/schema/founder.schema.json

@@ -67,6 +67,53 @@
           "type": "boolean"
         }
       }
+    },
+    "profile": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Who the founder is, in their own words, as a mentor learns it (Torian's playbook, step know-the-founder): the puzzle of their life and what they are for",
+      "properties": {
+        "puzzles": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The problems they keep turning over"
+        },
+        "passions": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "telos": {
+          "type": "string",
+          "description": "What a good life looks like for them; what they are for"
+        },
+        "ambitions": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "strengths": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "What people come to them for"
+        },
+        "values": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "confirmed": {
+          "type": "boolean",
+          "description": "The founder said the profile reads true"
+        }
+      }
     }
   }
 }

package/schema/playbook.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "playbook.schema.json",
+  "title": "Playbook",
+  "description": "A step-by-step guide a venture function runs, in conversation with the founder (a template is the empty shape of one record; a playbook is the order of the work). Each step says what the agent is trying to learn, how to hold the conversation, which records it writes and when the step is done. An agent proposes; the founder confirms what is written.",
+  "type": "object",
+  "required": ["id", "title", "purpose", "when", "steps"],
+  "additionalProperties": false,
+  "properties": {
+    "id": { "type": "string", "pattern": "^[a-z0-9-]+$" },
+    "title": { "type": "string" },
+    "purpose": { "type": "string", "description": "What the founder has at the end" },
+    "when": { "type": "string", "description": "When an agent should offer this playbook" },
+    "function": { "type": "string", "description": "The venture function that owns it" },
+    "phase": { "type": "string", "enum": ["discovery", "validation", "beachhead", "scale", "platform"] },
+    "sources": { "type": "array", "items": { "type": "string" }, "description": "Ideas the playbook is built on" },
+    "steps": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "goal", "conversation", "done_when"],
+        "additionalProperties": false,
+        "properties": {
+          "id": { "type": "string", "pattern": "^[a-z0-9-]+$" },
+          "title": { "type": "string" },
+          "goal": { "type": "string", "description": "What the agent is trying to learn or settle" },
+          "conversation": { "type": "array", "minItems": 1, "items": { "type": "string" }, "description": "How to hold the conversation: questions, moves, what to avoid" },
+          "writes": { "type": "array", "items": { "type": "object", "required": ["route"], "additionalProperties": false, "properties": { "route": { "type": "string" }, "as": { "type": "string", "enum": ["draft", "proposal", "evidence", "decision"] }, "note": { "type": "string" } } } },
+          "done_when": { "type": "string" },
+          "artifact": { "type": "string", "description": "The view to build for the founder at this step, per the choosing-artifacts skill" }
+        }
+      }
+    }
+  }
+}