@manifesto-ai/skills 0.1.1

package/LICENSE

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

package/SKILL.md

@@ -0,0 +1,40 @@
+# Manifesto Skills v0.1
+
+You are working on a Manifesto-based project. These rules are non-negotiable.
+
+## Absolute Rules
+
+1. **Core is pure.** No IO, no `Date.now()`, no side effects, no randomness. `compute()` is a pure function.
+2. **Snapshot is the only medium.** All communication between computations happens through Snapshot. No hidden channels, no return values from effects.
+3. **Three patch ops only.** `set`, `unset`, `merge` (shallow). No other mutation operations exist.
+4. **Effects are declarations.** Core declares requirements; Host executes them. Core never performs IO.
+5. **Errors are values.** Errors live in Snapshot state, never thrown. Core MUST NOT throw for business logic.
+6. **Flows terminate.** No unbounded loops in Flow. Host controls iteration. All guards required for re-entry safety.
+7. **`$` is reserved.** `$host`, `$mel`, `$system` are platform namespaces. Never use `$` in domain identifiers.
+
+## Normative Hierarchy
+
+SPEC > FDR > ADR > Code > README. Never invent semantics not in SPEC.
+
+## Task-Specific Knowledge
+
+Load these BEFORE writing code in each area:
+
+| Task | Knowledge File |
+|------|---------------|
+| Understanding Core/Host/World boundaries | `@knowledge/architecture.md` |
+| Writing MEL domain code | `@knowledge/mel-patterns.md` |
+| Implementing effect handlers | `@knowledge/effect-patterns.md` |
+| Working with state/patches | `@knowledge/patch-rules.md` |
+| Reviewing or debugging | `@knowledge/antipatterns.md` |
+| Looking up SPEC references | `@knowledge/spec-index.md` |
+
+## Self-Check
+
+Before submitting any code change, verify:
+
+- [ ] Determinism preserved? (same input → same output)
+- [ ] Snapshot is sole communication medium?
+- [ ] All mutations via patches?
+- [ ] No forbidden imports across package boundaries?
+- [ ] Flow guards present for re-entry safety?

package/claude-code/CLAUDE.md

@@ -0,0 +1,28 @@
+# Manifesto Development Rules
+
+This project uses the Manifesto framework. Read the rules below before writing any code.
+
+## Entry Point
+
+See @../SKILL.md for absolute rules and task-specific knowledge routing.
+
+## Knowledge Files
+
+Load the relevant file BEFORE writing code:
+
+- Architecture & boundaries: @../knowledge/architecture.md
+- Writing MEL code: @../knowledge/mel-patterns.md
+- Effect handler implementation: @../knowledge/effect-patterns.md
+- State mutations & patches: @../knowledge/patch-rules.md
+- Common mistakes to avoid: @../knowledge/antipatterns.md
+- SPEC document references: @../knowledge/spec-index.md
+
+## Quick Rules
+
+1. Core is pure — no IO, no side effects
+2. Snapshot is the only communication medium
+3. Only `set`, `unset`, `merge` patches exist
+4. Effects are declarations, not executions
+5. Errors are values in state, never thrown
+6. All Flow patches/effects must be guarded (when/once/onceIntent)
+7. `$` prefix is reserved for platform namespaces

package/knowledge/antipatterns.md

@@ -0,0 +1,256 @@
+# Antipatterns
+
+> Source: CLAUDE.md §10, Core FDR v2.0.0, Compiler SPEC v0.5.0 §8
+> Last synced: 2026-02-09
+
+If you see these patterns in code, REJECT the change.
+
+## Constitutional Violations
+
+### AP-001: Intelligent Host
+
+Host making policy decisions about effect execution.
+
+```typescript
+// FORBIDDEN
+async function executeEffect(req) {
+  if (shouldSkipEffect(req)) {  // Host deciding!
+    return [];
+  }
+}
+
+// Host MUST execute or report failure, never decide.
+```
+
+Why: Host executes, Core computes. Decision-making is Core's job. [FDR-001]
+
+### AP-002: Value Passing Outside Snapshot
+
+Returning values from effects for direct use, bypassing Snapshot.
+
+```typescript
+// FORBIDDEN
+const result = await executeEffect();
+core.compute(schema, snapshot, { ...intent, result });
+
+// CORRECT
+// Effect returns patches → Host applies → Next compute() reads from Snapshot
+```
+
+Why: Snapshot is the sole communication medium. [FDR-002]
+
+### AP-003: Execution-Aware Core
+
+Core branching on execution state it shouldn't know about.
+
+```typescript
+// FORBIDDEN
+if (effectExecutionSucceeded) { ... }
+
+// CORRECT
+if (snapshot.data.syncStatus === 'success') { ... }
+```
+
+Why: Core is pure. It reads Snapshot, nothing else. [FDR-001]
+
+### AP-004: Hidden Continuation State
+
+Storing execution context outside Snapshot.
+
+```typescript
+// FORBIDDEN
+const pendingCallbacks = new Map();  // Hidden state!
+
+// CORRECT — All execution state in snapshot.system.pendingRequirements
+```
+
+Why: There is no suspended execution context. [FDR-003]
+
+## Flow Violations
+
+### AP-005: Re-Entry Unsafe Flow
+
+Flow that runs every compute cycle without state guard.
+
+```mel
+// FORBIDDEN — runs every cycle!
+action increment() {
+  patch count = add(count, 1)       // Increments forever!
+  effect api.submit({ })            // Called every cycle!
+}
+
+// CORRECT
+action increment() {
+  onceIntent {
+    patch count = add(count, 1)
+    effect api.submit({ })
+  }
+}
+```
+
+Why: Flows are re-evaluated on every `compute()` call. Guards prevent re-execution. [FDR-006]
+
+### AP-006: Unbounded Loop in Flow
+
+Attempting Turing-complete loops in Flow.
+
+```mel
+// DOES NOT EXIST — no while/for in MEL
+while eq(pending, true) { ... }
+```
+
+Why: Flow must terminate in finite steps. Host controls iteration. [FDR-006]
+
+### AP-007: Nested Effects
+
+Effects inside other effects.
+
+```mel
+// FORBIDDEN
+effect array.map({
+  source: teams,
+  select: {
+    members: effect array.filter({   // Nested!
+      source: $item.members,
+      where: eq($item.active, true)
+    })
+  },
+  into: result
+})
+
+// CORRECT — Sequential composition
+effect array.flatMap({ source: teams, select: $item.members, into: allMembers })
+effect array.filter({ source: allMembers, where: eq($item.active, true), into: activeMembers })
+```
+
+Why: Effects are sequential declarations, not expressions. [Compiler SPEC §8.4]
+
+## State Violations
+
+### AP-008: Direct Snapshot Mutation
+
+```typescript
+// FORBIDDEN
+snapshot.data.count = 5;
+
+// CORRECT
+core.apply(schema, snapshot, [{ op: 'set', path: 'data.count', value: 5 }]);
+```
+
+Why: Snapshots are immutable. All mutations via patches. [FDR-002]
+
+### AP-009: Throwing in Effect Handler
+
+```typescript
+// FORBIDDEN
+async function handler(params) {
+  throw new Error('Something failed');
+}
+
+// CORRECT
+async function handler(params) {
+  return [{ op: 'set', path: 'data.error', value: 'Something failed' }];
+}
+```
+
+Why: Errors are values in Snapshot, never thrown. [FDR-005]
+
+## Type Violations
+
+### AP-010: String Paths in User API
+
+```typescript
+// FORBIDDEN
+{ path: '/data/todos/0/completed' }
+
+// CORRECT
+state.todos[0].completed  // TypeScript-checked FieldRef
+```
+
+Why: User-facing APIs must be type-safe with zero string paths.
+
+## Governance Violations
+
+### AP-011: Authority Bypass
+
+Executing intents without World Protocol.
+
+```typescript
+// FORBIDDEN
+host.execute(snapshot, intent);  // Skips governance!
+
+// CORRECT
+world.submitProposal(actor, intentInstance);
+// Authority evaluates → approved intents go to Host
+```
+
+Why: All intents must pass through World Protocol for governance and auditability.
+
+## MEL-Specific Mistakes
+
+### AP-012: Truthy/Falsy in Guards
+
+```mel
+// FORBIDDEN — items is not boolean
+when items { ... }
+
+// CORRECT
+when gt(len(items), 0) { ... }
+```
+
+### AP-013: Template Literals
+
+```mel
+// FORBIDDEN
+patch greeting = `Hello ${name}`
+
+// CORRECT
+patch greeting = concat("Hello ", name)
+```
+
+### AP-014: Using `$` in Domain Identifiers
+
+```mel
+// FORBIDDEN
+state { $myField: string = "" }
+
+// CORRECT
+state { myField: string = "" }
+```
+
+`$host`, `$mel`, `$system` are platform-reserved. Domain code must not use `$`.
+
+## Computed Violations
+
+### AP-015: Circular Computed Dependencies
+
+```mel
+// FORBIDDEN — cycle: a depends on b, b depends on a
+computed a = b
+computed b = a
+```
+
+Computed dependencies MUST form a DAG. Cycles are rejected at validation time. [Core SPEC §14 V-002]
+
+## Quick Checklist
+
+Before submitting code, verify NONE of these exist:
+
+- [ ] Host making decisions (not just executing)
+- [ ] Values passed outside Snapshot
+- [ ] Core knowing about execution state
+- [ ] Flow without state guard (patch/effect outside when/once/onceIntent)
+- [ ] Direct snapshot mutation
+- [ ] Throwing in effect handlers
+- [ ] String paths in user-facing API
+- [ ] Intent executed without governance
+- [ ] Nested effects
+- [ ] Truthy/falsy conditions in guards
+- [ ] Circular computed dependencies
+
+## Cross-References
+
+- Architecture rules: @knowledge/architecture.md
+- Correct MEL patterns: @knowledge/mel-patterns.md
+- Effect handler contract: @knowledge/effect-patterns.md
+- Patch rules: @knowledge/patch-rules.md

package/knowledge/architecture.md

@@ -0,0 +1,160 @@
+# Manifesto Architecture
+
+> Source: Core SPEC v2.0.1, Core FDR v2.0.0, Host SPEC v2.0.2, World SPEC v2.0.3
+> Last synced: 2026-02-09
+
+## Rules
+
+> **R1**: Core computes, Host executes. These concerns never mix. [FDR-001]
+> **R2**: Snapshot is the only medium of communication. If it's not in Snapshot, it doesn't exist. [FDR-002]
+> **R3**: There is no suspended execution context. All continuity is expressed through Snapshot. [FDR-003]
+> **R4**: Effects are declarations, not executions. Core declares; Host fulfills. [FDR-004]
+> **R5**: If you need a value, read it from Snapshot. There is no other place. [FDR-007]
+
+## The Constitution (7 Principles)
+
+```
+1. Core is a calculator, not an executor.
+2. Schema is the single source of truth.
+3. Snapshot is the only medium of communication.
+4. Effects are declarations, not executions.
+5. Errors are values, not exceptions.
+6. Everything is explainable.
+7. There is no suspended execution context.
+```
+
+## The Fundamental Equation
+
+```
+compute(schema, snapshot, intent, context) → (snapshot', requirements[], trace)
+```
+
+- **Pure**: Same input MUST always produce same output
+- **Total**: MUST always return a result (never throws)
+- **Traceable**: Every step MUST be recorded
+- If `requirements` is empty → computation complete
+- If `requirements` is non-empty → Host fulfills them, then calls `compute()` again
+
+## Data Flow
+
+```
+Actor submits Intent
+      ↓
+Bridge (Projection + Issuer → adds intentId, intentKey)
+      ↓
+World Protocol (Proposal + Authority)
+      ↓
+Host (compute loop + effect execution)
+      ↓
+Core (pure computation)
+      ↓
+New Snapshot (via patches)
+      ↓
+New World (immutable)
+```
+
+Information flows ONLY through Snapshot. No other channels exist.
+
+## Package Sovereignty
+
+| Package | Responsibility | MUST NOT |
+|---------|---------------|----------|
+| **Core** | Pure computation, expression evaluation, flow interpretation, patch generation, trace | IO, time, execution, know about Host/World |
+| **Host** | Effect execution, patch application, compute loop, requirement fulfillment | Make decisions, interpret semantics, suppress effects |
+| **World** | Proposal management, authority evaluation, decision recording, lineage | Execute effects, apply patches, compute transitions |
+| **App** | Composition root — wires Core + Host + World together | Contain domain logic |
+| **Bridge** | Two-way binding (events↔intents, snapshot↔subscribers) | Mutate, apply, execute, govern |
+
+## Forbidden Import Matrix
+
+| Package | MUST NOT Import |
+|---------|----------------|
+| core | host, world, bridge, react |
+| host | world governance, react |
+| world | host internals, core compute |
+| bridge | core internals, host handlers, world internals |
+| react | core internals, host, world |
+
+## Snapshot Structure
+
+```typescript
+type Snapshot = {
+  data: TData;                    // Domain state (+ platform namespaces $host, $mel)
+  computed: Record<string, unknown>; // Derived values (always recalculated)
+  system: {
+    status: 'idle' | 'computing' | 'pending' | 'error';
+    lastError: ErrorValue | null;
+    errors: readonly ErrorValue[];
+    pendingRequirements: readonly Requirement[];
+    currentAction: string | null;
+  };
+  input: unknown;                 // Transient action input
+  meta: {
+    version: number;              // Monotonically increasing
+    timestamp: number;
+    randomSeed: string;
+    schemaHash: string;
+  };
+};
+```
+
+## Platform Namespaces
+
+- `$host` — Host-owned internal state (intent slots, execution context). Excluded from hash.
+- `$mel` — Compiler-owned guard state (`$mel.guards.*`). Excluded from hash.
+- `$system.*` — System values (uuid, time.now). Lowered to effects by compiler.
+- Domain schemas MUST NOT define `$`-prefixed fields.
+
+## Computation Cycle
+
+```
+Host calls compute(schema, snapshot, intent, context)
+  → Core evaluates Flow until:
+    - Flow completes (requirements=[]) → DONE
+    - Effect encountered (requirements=[...]) → Host executes effects, applies patches, calls compute() AGAIN
+    - Error occurs → error recorded in Snapshot
+```
+
+Each `compute()` is complete and independent. There is no "resume".
+
+## Antipatterns
+
+### Intelligent Host
+```typescript
+// FORBIDDEN — Host making decisions
+if (shouldSkipEffect(req)) { return []; }
+
+// Host MUST execute or report failure, never decide
+```
+
+### Value Passing Outside Snapshot
+```typescript
+// FORBIDDEN
+const result = await executeEffect();
+core.compute(schema, snapshot, { ...intent, result });
+
+// CORRECT — Effect returns patches → Host applies → Core reads from Snapshot
+```
+
+### Execution-Aware Core
+```typescript
+// FORBIDDEN — Core cannot know about execution
+if (effectExecutionSucceeded) { ... }
+
+// CORRECT — Core reads state
+if (snapshot.data.syncStatus === 'success') { ... }
+```
+
+## Why
+
+Separation of concerns enables:
+- **Determinism**: Core testable without mocks (same input → same output)
+- **Auditability**: World tracks all governance decisions with lineage
+- **Portability**: Host swappable per environment (browser/server/edge/WASM)
+- **Reproducibility**: Snapshot serialization enables time-travel debugging
+
+## Cross-References
+
+- MEL syntax: @knowledge/mel-patterns.md
+- Effect handlers: @knowledge/effect-patterns.md
+- Patch operations: @knowledge/patch-rules.md

package/knowledge/effect-patterns.md

@@ -0,0 +1,187 @@
+# Effect Patterns
+
+> Source: Host SPEC v2.0.2 §7, App SPEC v2.3.0 §8, Core FDR v2.0.0
+> Last synced: 2026-02-09
+
+## Rules
+
+> **R1**: Effect handlers MUST return `Patch[]` and MUST NOT throw exceptions. [HANDLER-1, HANDLER-2]
+> **R2**: Failures MUST be expressed as patches to state (error values in Snapshot). [HANDLER-3]
+> **R3**: Effect handlers MUST NOT contain domain logic. They are pure IO adapters. [HANDLER-4, HANDLER-5]
+> **R4**: Effects are declared by Core, executed by Host. Core never performs IO. [FDR-004]
+> **R5**: Host-generated error patches MUST target `$host` or domain-owned paths, NOT `system.*`. [INV-SNAP-4]
+
+## Handler Contract
+
+Developers register effect handlers through the **App layer** API:
+
+```typescript
+// App-layer handler signature (what you write)
+type EffectHandler = (
+  params: unknown,
+  ctx: AppEffectContext
+) => Promise<readonly Patch[]>;
+
+type Patch = {
+  op: 'set' | 'unset' | 'merge';
+  path: string;
+  value?: unknown;
+};
+```
+
+Note: The Host layer internally uses a different signature `(type, params, context)` but App wraps this. Handlers receive effect params, perform IO, and return patches.
+
+## Patterns
+
+### Successful Effect
+
+```typescript
+async function fetchUser(params: { id: string }): Promise<Patch[]> {
+  const response = await fetch(`/users/${params.id}`);
+  const data = await response.json();
+  return [
+    { op: 'set', path: 'data.user', value: data },
+    { op: 'set', path: 'data.user.error', value: null }
+  ];
+}
+```
+
+### Failed Effect (Errors as Patches)
+
+```typescript
+async function fetchUser(params: { id: string }): Promise<Patch[]> {
+  try {
+    const response = await fetch(`/users/${params.id}`);
+    if (!response.ok) {
+      return [
+        { op: 'set', path: 'data.user.error', value: { code: response.status } },
+        { op: 'set', path: 'data.user.data', value: null }
+      ];
+    }
+    const data = await response.json();
+    return [
+      { op: 'set', path: 'data.user.data', value: data },
+      { op: 'set', path: 'data.user.error', value: null }
+    ];
+  } catch (error) {
+    return [
+      { op: 'set', path: 'data.user.error', value: { message: error.message } },
+      { op: 'set', path: 'data.user.data', value: null }
+    ];
+  }
+}
+```
+
+### Effect Registration (App Layer)
+
+```typescript
+import { createManifestoApp } from '@manifesto-ai/app';
+
+const app = createManifestoApp({
+  schema: domainSchema,
+  effects: {
+    'api.fetchUser': fetchUser,
+    'api.createTodo': createTodo,
+    'payment.process': processPayment,
+  },
+});
+```
+
+Effect names in handlers must match effect type names declared in MEL.
+
+### Collection Effect Handlers
+
+Collection effects (`array.filter`, `array.map`, `record.keys`, etc.) are built-in — you do NOT write handlers for these. They are handled by Core/Host internally.
+
+You only write handlers for custom domain effects (API calls, storage, etc.).
+
+## Antipatterns
+
+### Throwing Handler
+
+```typescript
+// FORBIDDEN
+async function bad(params) {
+  if (!params.id) throw new Error('Missing id');  // Don't throw!
+  const result = await api.call(params.id);
+  return [{ op: 'set', path: 'data.result', value: result }];
+}
+
+// CORRECT
+async function good(params) {
+  if (!params.id) {
+    return [{ op: 'set', path: 'data.error', value: 'Missing id' }];
+  }
+  const result = await api.call(params.id);
+  return [{ op: 'set', path: 'data.result', value: result }];
+}
+```
+
+### Domain Logic in Handler
+
+```typescript
+// FORBIDDEN — Business rule in handler
+async function purchaseHandler(params) {
+  if (params.amount > 1000) {  // Domain decision!
+    return [{ op: 'set', path: 'data.approval.required', value: true }];
+  }
+  // ...
+}
+
+// CORRECT — Handler does IO only, domain logic stays in Flow/MEL
+async function paymentHandler(params) {
+  const result = await paymentGateway.charge(params.amount);
+  return [{ op: 'set', path: 'data.payment.status', value: result.status }];
+}
+```
+
+### Returning Raw Values
+
+```typescript
+// FORBIDDEN — Returns value, not patches
+async function bad(params) {
+  return await api.fetchData(params.id);  // Returns data directly!
+}
+
+// CORRECT — Returns patches
+async function good(params) {
+  const data = await api.fetchData(params.id);
+  return [{ op: 'set', path: 'data.result', value: data }];
+}
+```
+
+### Writing to system.*
+
+```typescript
+// FORBIDDEN — Handler must not write system namespace
+return [{ op: 'set', path: 'system.lastError', value: { ... } }];
+
+// CORRECT — Write to $host or domain paths
+return [{ op: 'set', path: 'data.fetchError', value: { ... } }];
+```
+
+## Requirement Lifecycle
+
+When Core encounters an effect declaration:
+1. Core records a Requirement in `system.pendingRequirements`
+2. Core terminates and returns to Host
+3. Host executes the effect handler
+4. Host applies result patches to Snapshot
+5. Host MUST clear the requirement from `pendingRequirements`
+6. Host calls `compute()` again
+
+**Critical**: Requirement MUST be cleared even if handler fails. Leaving it pending causes infinite loops.
+
+## Why
+
+**Patches as protocol**: Decouples effect execution from Core. Host can serialize, batch, retry, or substitute effects without Core knowing.
+
+**Errors as values**: Same inputs (including failures) always produce same snapshot state. Enables deterministic replay.
+
+**No domain logic**: Keeps all business decisions in Flow/MEL where they are traceable and deterministic.
+
+## Cross-References
+
+- Patch operations: @knowledge/patch-rules.md
+- State structure: @knowledge/architecture.md
+- MEL effect declarations: @knowledge/mel-patterns.md

package/knowledge/mel-patterns.md

@@ -0,0 +1,234 @@
+# MEL Patterns
+
+> Source: Compiler SPEC v0.5.0, Compiler FDR v0.5.0
+> Last synced: 2026-02-09
+
+## Rules
+
+> **R1**: MEL is pure and total. All expressions terminate, are deterministic, and never throw. [A1-A3]
+> **R2**: One pattern per concept. Function calls only, no method chaining. [A6]
+> **R3**: Every mutation (patch/effect) MUST be inside a guard (when/once/onceIntent). [A7]
+> **R4**: Effects are declarations, not executions. Effects are sequential, never nested. [A20]
+> **R5**: `$` is completely prohibited in user identifiers — not just at start, anywhere. [A28]
+
+## Domain Structure
+
+```mel
+domain MyApp {
+  state {
+    count: number = 0
+    name: string | null = null
+    items: Record<string, Item> = {}
+    marker: string | null = null     // for once() guard
+  }
+
+  computed total = mul(price, quantity)
+  computed hasItems = gt(len(items), 0)
+
+  action increment() { ... }
+  action addItem(title: string) { ... }
+}
+```
+
+## Guard Patterns (Re-Entry Safety)
+
+Every compute cycle re-evaluates the entire flow. Without guards, patches and effects run every cycle.
+
+### `onceIntent` — Per-intent idempotency (preferred)
+
+```mel
+action submit() {
+  onceIntent {
+    patch status = "submitting"
+    effect api.submit({ data: formData, into: result })
+  }
+}
+```
+
+Compiler desugars to: stores guard in `$mel.guards.intent`, checks `$meta.intentId`.
+
+### `once(marker)` — Explicit marker guard
+
+```mel
+action addTask(title: string) {
+  once(addingTask) when neq(trim(title), "") {
+    patch addingTask = $meta.intentId    // MUST be first statement
+    patch tasks[$system.uuid] = {
+      id: $system.uuid,
+      title: trim(title),
+      completed: false
+    }
+  }
+}
+```
+
+Rule: `patch marker = $meta.intentId` MUST be the first statement inside `once()`.
+
+### `when` — Conditional guard
+
+```mel
+action setFilter(newFilter: string) {
+  when neq(filter, newFilter) {
+    patch filter = newFilter
+  }
+}
+```
+
+Conditions MUST be boolean expressions — no truthy/falsy coercion. Use `gt(len(items), 0)` not `when items`.
+
+## Expression Syntax
+
+```mel
+// Arithmetic
+add(a, b)  sub(a, b)  mul(a, b)  div(a, b)  mod(a, b)  neg(a)
+
+// Math
+abs(n)  min(a, b)  max(a, b)  floor(n)  ceil(n)  round(n)  sqrt(n)  pow(base, exp)
+
+// Comparison (primitive-only — cannot compare Array/Object/Record)
+eq(a, b)  neq(a, b)  gt(a, b)  gte(a, b)  lt(a, b)  lte(a, b)
+
+// Logical
+and(a, b)  or(a, b)  not(a)
+
+// Null handling
+isNull(x)  isNotNull(x)  coalesce(a, b, c)
+
+// Conditional
+cond(condition, thenValue, elseValue)    // NOT if()
+
+// String
+concat("Hello ", name)  trim(s)  lower(s)  upper(s)  substr(s, 0, 10)  strlen(s)
+
+// Conversion
+toString(x)
+
+// Array/Collection
+len(arr)  first(arr)  last(arr)  at(arr, index)
+
+// Aggregation (primitive arrays only)
+sum(arr)  min(arr)  max(arr)
+```
+
+No method calls: `str.trim()` is a SyntaxError. Use `trim(str)`.
+Index access `x[y]` desugars to `at(x, y)` — works for both Array and Record.
+
+## Effect Syntax
+
+```mel
+// Basic effect with into path
+effect api.fetchUser({ id: userId, into: userData })
+
+// Collection effects use $item for iteration
+effect array.filter({
+  source: tasks,
+  where: eq($item.completed, false),
+  into: activeTasks
+})
+
+effect array.map({
+  source: users,
+  select: { name: $item.name, active: $item.isActive },
+  into: userSummaries
+})
+
+// Record operations
+effect record.filter({ source: items, where: ..., into: items })
+effect record.keys({ source: items, into: itemIds })
+```
+
+## Multi-Step Actions
+
+```mel
+action checkout() {
+  // Step 1: Validate
+  once(cart.validatedAt) {
+    patch cart.validatedAt = $meta.intentId
+    effect validate.cart({ items: cart.items, into: cart.validation })
+  }
+
+  // Step 2: Pay (only after validation)
+  once(payment.processedAt) when cart.validation.success {
+    patch payment.processedAt = $meta.intentId
+    effect payment.process({ amount: cart.total, into: payment.result })
+  }
+
+  // Step 3: Create order (only after payment)
+  once(order.createdAt) when payment.result.success {
+    patch order.createdAt = $meta.intentId
+    effect order.create({ items: cart.items, into: order.result })
+  }
+}
+```
+
+Each `once()` guard ensures its block runs exactly once. Effects write results to Snapshot; subsequent guards read from Snapshot.
+
+## Forbidden Constructs
+
+### Syntactically Forbidden
+```mel
+let x = 5          // No variables
+const y = 10       // No constants
+function foo() {}  // No function definitions
+for (...) {}       // No loops
+while (...) {}     // No loops
+str.trim()         // No method calls (use trim(str))
+if (cond) {}       // No if/else (use when guard or cond() expression)
+throw new Error()  // No exceptions
+async/await        // No async
+class Foo {}       // No classes
+```
+
+### Semantically Forbidden
+```mel
+filter(items, ...)  // Not a builtin — use effect array.filter()
+Date.now()          // Not defined — use $system.time.now
+Math.random()       // Not defined — determinism required
+```
+
+## LLM Generation Checklist
+
+1. All operations use `functionName(arg1, arg2)` syntax
+2. Property access uses `object.property` (no method calls)
+3. Index access uses `array[index]` or `record[key]` (desugars to `at()`)
+4. Effects use `effect type.name({ param: value, into: path })`
+5. Guards use `when condition { body }`, `once(marker) { body }`, or `onceIntent { body }`
+6. Iteration variable is always `$item` (current element)
+7. Effects are never nested — use sequential effects with intermediate `into:` paths
+8. For nested data, use `flatMap` to flatten, then `filter`/`map`, then `groupBy` to restructure
+9. All patch/effect must be inside guards
+10. Conditions must be boolean expressions — no truthy/falsy (`when items` is wrong)
+11. Markers use intentId — `once(m) { patch m = $meta.intentId; ... }`
+12. Use correct effect family — `array.*` for Array, `record.*` for Record
+13. Use `concat()` for strings — no template literals
+14. Use `cond()` not `if()` — `cond(condition, thenValue, elseValue)`
+15. Computed can reference computed — scope: Params > Computed > State > System
+16. `$system.*` is deduplicated per action — same key = same value
+17. `neq(null, string)` = true — different types are never equal
+18. `eq`/`neq` are primitive-only — cannot compare Array/Object/Record
+19. `$` is completely prohibited in identifiers — not just at start, anywhere
+20. `once()` marker must be first — `patch marker = $meta.intentId` as first statement
+21. Index access `x[y]` is always `call(at)` in IR — not `get` with index
+22. Evaluation is left-to-right — object fields are key-sorted first, then left-to-right
+23. `partition` uses top-level `pass:` and `fail:` — not `into: { pass, fail }`
+24. `$system.*` only in actions — forbidden in computed and state initializers
+25. System values are IO — compiler handles lowering, developer writes surface syntax
+26. `__sys__` prefix reserved — user identifiers cannot start with `__sys__` (compile error E004)
+27. Readiness uses `eq(intent, intentId)` — NOT `isNotNull(value)`, prevents stale value bugs
+28. `available when <Expr>` for action preconditions — must be pure (no effects, no `$system.*`)
+29. `fail` and `stop` must be guarded — unconditional is compile error
+30. `stop` is early-exit, not "waiting" — `"Waiting for..."` messages are lint errors
+31. Named types required — anonymous object types in state are forbidden
+32. Type declarations are metadata — AI-readable domain concepts
+
+## Why
+
+**Purity by design**: Impossible to express side effects in grammar = impossible to violate purity.
+
+**AI-Native**: Grammar optimized for LLM generation. One pattern per concept reduces hallucination. Forbidden constructs don't parse, preventing common mistakes.
+
+## Cross-References
+
+- Architecture context: @knowledge/architecture.md
+- Effect handler implementation: @knowledge/effect-patterns.md
+- Common mistakes: @knowledge/antipatterns.md

package/knowledge/patch-rules.md

@@ -0,0 +1,141 @@
+# Patch Rules
+
+> Source: Core SPEC v2.0.1 §13.3-14, Core FDR v2.0.0 FDR-012
+> Last synced: 2026-02-09
+
+## Rules
+
+> **R1**: Only three patch operations exist: `set`, `unset`, `merge`. [Core SPEC §8.4.3]
+> **R2**: All state changes MUST go through `apply(schema, snapshot, patches)`. [Core SPEC §13.3]
+> **R3**: Patches create a new Snapshot. The old Snapshot is unchanged (immutable). [Core SPEC §13.3]
+> **R4**: `version` MUST be incremented on every change. [Core SPEC §13.3]
+> **R5**: Patch paths MUST be statically resolvable. Dynamic paths require two-step pattern. [Core SPEC §8.4.3]
+
+## The Three Operations
+
+### `set` — Replace value at path (create if missing)
+
+```typescript
+{ op: 'set', path: 'data.count', value: 5 }
+{ op: 'set', path: 'data.todos.abc123.completed', value: true }
+{ op: 'set', path: 'data.items', value: [1, 2, 3] }
+```
+
+### `unset` — Remove property at path
+
+```typescript
+{ op: 'unset', path: 'data.tempFlag' }
+{ op: 'unset', path: 'data.todos.abc123' }
+```
+
+### `merge` — Shallow merge object at path
+
+```typescript
+{ op: 'merge', path: 'data.user', value: { lastSeen: '2026-02-09' } }
+```
+
+**Warning: Shallow only.** Nested objects are replaced, not recursively merged. For nested updates, use multiple `set` patches.
+
+If merge target is absent, treated as `{}`. If merge target is non-object, runtime validation failure.
+
+## MEL Patch Syntax
+
+```mel
+// set
+patch count = add(count, 1)
+patch user.name = trim(newName)
+patch items[$system.uuid] = { id: $system.uuid, title: title }
+
+// unset
+patch tasks[id] unset
+
+// merge (only via effect results or explicit merge op)
+```
+
+## Dynamic Path Pattern
+
+Patch paths must be static at apply-time. For dynamic keys:
+
+```mel
+// Step 1: Fix the dynamic value to Snapshot
+once(creating) {
+  patch creating = $meta.intentId
+  patch newItemId = $system.uuid    // UUID now in Snapshot
+}
+
+// Step 2: Use the fixed value
+when isNotNull(newItemId) {
+  patch items[newItemId] = { id: newItemId, title: title }
+}
+```
+
+Compiler handles the lowering. `$system.uuid` becomes an effect that writes the value to a state slot.
+
+## Antipatterns
+
+### Direct Mutation
+
+```typescript
+// FORBIDDEN
+snapshot.data.count = 5;
+snapshot.meta.version++;
+
+// CORRECT
+const newSnapshot = core.apply(schema, snapshot, [
+  { op: 'set', path: 'data.count', value: 5 }
+]);
+```
+
+### Deep Merge Assumption
+
+```typescript
+// WRONG — merge is shallow, nested objects replaced entirely
+{ op: 'merge', path: 'data', value: { user: { name: 'X', settings: { theme: 'dark' } } } }
+
+// CORRECT — multiple set patches for nested paths
+[
+  { op: 'set', path: 'data.user.name', value: 'X' },
+  { op: 'set', path: 'data.user.settings.theme', value: 'dark' }
+]
+```
+
+### Array Push/Pop/Splice
+
+```typescript
+// FORBIDDEN — mutates in place
+snapshot.data.todos.push(newTodo);
+
+// CORRECT — set entire new array
+const newTodos = [...snapshot.data.todos, newTodo];
+[{ op: 'set', path: 'data.todos', value: newTodos }]
+```
+
+### Unguarded Patch in MEL
+
+```mel
+// FORBIDDEN — runs every compute cycle
+action broken() {
+  patch count = add(count, 1)     // Increments forever!
+}
+
+// CORRECT — guarded
+action increment() {
+  onceIntent {
+    patch count = add(count, 1)
+  }
+}
+```
+
+## Why
+
+**Three operations are enough.** Complexity is composed, not built-in. [FDR-012]
+
+**Immutability.** Snapshots are time-travel points. Mutation breaks determinism and reproducibility.
+
+**Version tracking.** Monotonic version enables conflict detection and audit trails.
+
+## Cross-References
+
+- Snapshot structure: @knowledge/architecture.md
+- Effect handlers return patches: @knowledge/effect-patterns.md
+- MEL patch syntax: @knowledge/mel-patterns.md

package/knowledge/spec-index.md

@@ -0,0 +1,105 @@
+# SPEC Index
+
+> Source: docs/llm/LLM-INDEX.md
+> Last synced: 2026-02-09
+
+## Normative Hierarchy
+
+1. **SPEC** — highest authority
+2. **FDR** — design rationale; must not contradict SPEC
+3. **ADR** — architectural decisions; must not contradict SPEC/FDR
+4. **Code** — implementation
+5. **README** — lowest authority
+
+When documents conflict, prefer higher-ranked sources.
+
+## How to Read Patch Documents
+
+Some SPECs are published as base + patch. Read the base first, then apply the patch. The composed document is authoritative.
+
+Example: Core v2.0.1 = `SPEC-v2.0.0.md` + `SPEC-v2.0.1-patch.md`
+
+## Core Packages
+
+### Core v2.0.1
+
+- Base: `packages/core/docs/SPEC-v2.0.0.md`
+- Patch: `packages/core/docs/SPEC-v2.0.1-patch.md`
+- FDR: `packages/core/docs/FDR-v2.0.0.md`
+
+Key sections: §3 Constitution, §8 FlowSpec, §13 Snapshot, §14 Validation, §16 Host Interface
+
+### Host v2.0.2
+
+- `packages/host/docs/host-SPEC-v2.0.2.md`
+- FDR: `packages/host/docs/host-FDR-v2.0.2.md`
+
+Key sections: §7 Effect Handler Contract, §8 Requirement Lifecycle, §10 Execution Model, §13 Error Handling
+
+### World v2.0.3
+
+- `packages/world/docs/world-SPEC-v2.0.3.md`
+- Patches: `world-SPEC-v2.0.5-patch.md`
+- FDR: `packages/world/docs/world-FDR-v2.0.2.md`
+
+Key sections: Governance, Proposals, Authority, Head semantics, Branch persistence
+
+## Application Layer
+
+### App v2.3.1 (base + patches)
+
+- Base: `packages/app/docs/APP-SPEC-v2.0.0.md`
+- Patches: `APP-SPEC-v2.1.0-patch.md`, `APP-SPEC-v2.3.0.md`, `APP-SPEC-v2.3.1-patch.md`
+- FDRs: Multiple (integration, policy, runtime, ext, pub)
+
+Key sections: §8 Host Integration (effect registration)
+
+### Compiler (MEL) v0.5.0
+
+- `packages/compiler/docs/SPEC-v0.5.0.md`
+- FDR: `packages/compiler/docs/FDR-v0.5.0.md`
+
+Key sections: §2 Design Principles, §4 Syntax, §6 Semantic Rules, §8 Forbidden Constructs, §14 Examples, §21 $mel Namespace, Appendix (LLM 34-rule checklist)
+
+## Intent + Translation
+
+### Intent IR v0.2.0
+
+- `packages/intent-ir/docs/SPEC-v0.2.0.md`
+- FDR: `packages/intent-ir/docs/FDR-v0.1.0.md`
+
+### Translator v1.0.3
+
+- `packages/translator/core/docs/translator-SPEC-v1.0.3.md`
+- FDR: `packages/translator/core/docs/translator-FDR-v0.11.md`
+
+## Global ADRs
+
+- ADR-002: onceIntent + $mel namespace → `docs/adr/adr-002-onceIntent-mel-namespace.md`
+
+## Quick Lookup
+
+| Need to understand... | Go to |
+|----------------------|-------|
+| Snapshot structure | Core SPEC §13 |
+| Patch operations | Core SPEC §8.4.3, §14 |
+| Effect handler contract | Host SPEC §7, §13 |
+| MEL syntax | Compiler SPEC §4 |
+| Flow guards (when/once/onceIntent) | Compiler SPEC §21 |
+| Forbidden constructs | Compiler SPEC §8 |
+| World governance | World SPEC §5-8 |
+| App composition | App SPEC §8 |
+| LLM code generation rules | Compiler SPEC Appendix |
+
+## FDR Canonical Statements
+
+| Statement | Source |
+|-----------|--------|
+| "Core computes. Host executes. These concerns never mix." | FDR-001 |
+| "If it's not in Snapshot, it doesn't exist." | FDR-002 |
+| "There is no suspended execution context." | FDR-003 |
+| "Core declares requirements. Host fulfills them." | FDR-004 |
+| "Errors are values. They live in Snapshot. They never throw." | FDR-005 |
+| "Flows always terminate. Unbounded iteration is Host's responsibility." | FDR-006 |
+| "If you need a value, read it from Snapshot. There is no other place." | FDR-007 |
+| "Three operations are enough. Complexity is composed, not built-in." | FDR-012 |

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@manifesto-ai/skills",
+  "version": "0.1.1",
+  "description": "LLM knowledge pack for Manifesto — patterns, rules, and antipatterns for AI-assisted development",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "manifesto",
+    "llm",
+    "claude-code",
+    "cursor",
+    "ai-coding",
+    "skills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/manifesto-ai/core.git",
+    "directory": "skills"
+  },
+  "files": [
+    "SKILL.md",
+    "knowledge/**",
+    "claude-code/**",
+    "scripts/**",
+    "tracking/**"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs"
+  }
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+/**
+ * @manifesto-ai/skills postinstall
+ *
+ * Provides integration instructions after installation.
+ * v0.1: Simple message output only.
+ */
+
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const skillsRoot = resolve(__dirname, '..');
+
+console.log(`
+@manifesto-ai/skills v0.1.0 installed
+
+Knowledge files available at:
+  ${skillsRoot}/SKILL.md
+
+Claude Code integration:
+  Add to your CLAUDE.md:
+    See @node_modules/@manifesto-ai/skills/SKILL.md for Manifesto development rules.
+`);

package/tracking/source-map.json

@@ -0,0 +1,67 @@
+{
+  "version": "0.1.0",
+  "lastChecked": "2026-02-09",
+  "mappings": [
+    {
+      "skill": "SKILL.md",
+      "sources": [
+        { "path": "CLAUDE.md", "version": "1.0", "sections": ["§1", "§2", "§3", "§11"] },
+        { "path": "packages/core/docs/SPEC-v2.0.0.md", "version": "2.0.0", "sections": ["§3"] }
+      ],
+      "lastSynced": "2026-02-09"
+    },
+    {
+      "skill": "knowledge/architecture.md",
+      "sources": [
+        { "path": "packages/core/docs/SPEC-v2.0.0.md", "version": "2.0.0", "sections": ["§3", "§13", "§16"] },
+        { "path": "packages/core/docs/SPEC-v2.0.1-patch.md", "version": "2.0.1" },
+        { "path": "packages/core/docs/FDR-v2.0.0.md", "version": "2.0.0", "sections": ["FDR-001", "FDR-002", "FDR-003", "FDR-004", "FDR-007"] },
+        { "path": "packages/host/docs/host-SPEC-v2.0.2.md", "version": "2.0.2", "sections": ["§7", "§8", "§10"] },
+        { "path": "packages/world/docs/world-SPEC-v2.0.3.md", "version": "2.0.3" }
+      ],
+      "lastSynced": "2026-02-09"
+    },
+    {
+      "skill": "knowledge/mel-patterns.md",
+      "sources": [
+        { "path": "packages/compiler/docs/SPEC-v0.5.0.md", "version": "0.5.0", "sections": ["§2", "§4", "§6", "§8", "§14", "§21", "LLM Checklist"] },
+        { "path": "packages/compiler/docs/FDR-v0.5.0.md", "version": "0.5.0" }
+      ],
+      "lastSynced": "2026-02-09"
+    },
+    {
+      "skill": "knowledge/effect-patterns.md",
+      "sources": [
+        { "path": "packages/host/docs/host-SPEC-v2.0.2.md", "version": "2.0.2", "sections": ["§7", "§13"] },
+        { "path": "packages/host/docs/host-FDR-v2.0.2.md", "version": "2.0.2" },
+        { "path": "packages/app/docs/APP-SPEC-v2.3.0.md", "version": "2.3.0", "sections": ["§8"] }
+      ],
+      "lastSynced": "2026-02-09"
+    },
+    {
+      "skill": "knowledge/patch-rules.md",
+      "sources": [
+        { "path": "packages/core/docs/SPEC-v2.0.0.md", "version": "2.0.0", "sections": ["§13.3", "§14"] },
+        { "path": "packages/core/docs/SPEC-v2.0.1-patch.md", "version": "2.0.1" },
+        { "path": "packages/core/docs/FDR-v2.0.0.md", "version": "2.0.0", "sections": ["FDR-012"] }
+      ],
+      "lastSynced": "2026-02-09"
+    },
+    {
+      "skill": "knowledge/antipatterns.md",
+      "sources": [
+        { "path": "CLAUDE.md", "version": "1.0", "sections": ["§10"] },
+        { "path": "packages/core/docs/FDR-v2.0.0.md", "version": "2.0.0" }
+      ],
+      "note": "Accumulated from real usage feedback and constitutional violations.",
+      "lastSynced": "2026-02-09"
+    },
+    {
+      "skill": "knowledge/spec-index.md",
+      "sources": [
+        { "path": "docs/llm/LLM-INDEX.md", "version": "latest" }
+      ],
+      "lastSynced": "2026-02-09"
+    }
+  ]
+}