ContextLattice v3.13.0 - Memory That Learns Without Grabbing the Wheel

v3.13 turns outcomes into policy evidence and repeated wins into reusable
skills. It does not confuse learning with permission.

What changed

• Added an outcome-trained context-policy ledger. Only calibration-eligible
  outcomes can seed a candidate.
• Added one-step candidate -> shadow -> canary -> promoted|rolled_back
  lifecycle gates. Phases cannot be skipped.
• Added controlled control/canary comparisons across first-pass success, repair
  rate, follow-up tokens, and provider tokens. Evidence is candidate-, project-,
  and phase-scoped; mixed operator/persisted arms are rejected.
• Added explicit policy ID, arm, and phase attribution to adapter and task-worker
  outcome reports.
• Added Skill Foundry. Three repeated verified runs can become a draft; three
  separate holdouts must reproduce it; export requires named human approval.
• Added explicit skill version, supersession, collision, and non-automatic
  retirement metadata so a generated update cannot silently replace behavior.
• Bound candidate IDs to evidence digests and skill evaluations to immutable
  draft fingerprints. Holdouts require explicit identities and evidence refs.
• Made policy and skill lifecycles replay-safe: stale policy transitions fail,
  candidate regeneration cannot reset phases, and identical draft replay cannot
  regress evaluated/exported state.
• Treats promoted and rolled_back as terminal policy phases, and parses
  Skills Index root lists with the OS-native separator so Windows drive letters
  are not split as Unix path lists.
• Added seven primary CLI commands for policy and skill workflows, plus native
  HTTP/tool/telemetry routes and five bounded contracts.
• Expanded native-ownership, context-boundary, installer, audit, preflight, and
  public-core parity coverage from 17 to 19 capabilities.

The boundary

• Public policy records are advisory. Even a promoted record has
  runtime_activation=false.
• Skill exports are inactive artifacts. Public ContextLattice never writes them
  into an active skill root.
• Infrastructure failures remain observable but cannot train context policy.
• Canary promotion needs controlled evidence and a measurable benefit while
  every guardrail passes.
• A material regression recommends rollback.
• No model call, external network call, Python application service, or gateway
  subprocess was added.

Measured behavior

Five-run component benchmarks on the release development host:

• Candidate generation from 100 outcomes: median 261342 ns/op, 284760 B/op,
  1079 allocs/op.
• Canary gate: median 1082 ns/op, 2320 B/op, 24 allocs/op.
• Skill draft from 20 verified runs: median 91512 ns/op, 58270 B/op,
  1004 allocs/op.
• Model calls: 0.
• External network calls: 0.

These are bounded administrative component benchmarks, not universal latency
promises. Reproduce them with docs/evals/v3.13-outcome-policy-skill-foundry.json.

Try it

contextlattice_policy_candidate --project contextlattice --pretty
contextlattice_policy_status --pretty
contextlattice_skill_foundry_status --pretty

The full workflow and payload shapes are documented in
docs/outcome-policy-skill-foundry.md.