implement

name	implement
description	Use when the slice portion is locked and its derived tests exist, to build all of the locked portion to green autonomously. Triggers at implement start and on every re-entry after a human turn. Do not use to declare green (slice-exit does that), and do not use it for an unexplained runtime defect (problem-solve).

X2 Implement

Build the slice: generate, verify, correct, re-verify, running to green without human turns wherever you honestly can. The kernel enforces the invariants; this skill exists to capture the decisions the kernel cannot make and to keep the drive honest.

The contract you are building to

All of the locked portion. Fidelity to the whole approved contract, no silently dropped pieces (this is what gate 3 ratifies, through the exit report). The pilot's dark-only theme flip is the canonical violation: a visible piece of the locked contract quietly dropped while everything read as done. "All of it" means all of the locked portion; the rest of the prototype is the design spine awaiting its slices.

The human-turn contract (stop only for these)

• Record-gap: a decision no record answers (not in D-000, the deltas, or the locked prototype) that is novel and not cheaply reversible. File a one-line question; the answer becomes a D-0xx. Commodity decisions you make yourself from priors with a one-line note. A real example of a record-gap: a reuse-versus-build call on an existing component; the kernel is provenance-blind by design and the economics are local to the slice.
• Green-but-wrong: tests green, result wrong against the story or the locked prototype. Surface it; the fix goes in the decision file, never patched into source.
• Unconditional turns: any persistent-schema migration or published-contract change, every time, no exception.
• Suspected kernel defect: stop and report it with why it looks like a kernel defect. The kernel is fixed canonically, never patched locally without a ruling.

When unsure whether something is a turn, surface it and let intake classify it. Never absorb it silently, and never manufacture a turn for a commodity choice.

Standing rules, now held by the gates

These were settled by the record and, since the invariants pass (2026-07-11), are enforced by the kernel; the notes here say what the gate will do so you work with it, not around it.

• The client UI is a thin layer over testable client services (UI-5). The composition root constructs the client and delegates; screens receive data and callbacks. The eslint import ban rejects transport or data-service imports outside the composition root (type-only imports are legal), and the composed-entrypoint smoke proves a real request leaves the app per primary flow. Each NEW primary flow owes its smoke line; that is your per-slice obligation, checked in the exit report's coverage table.
• Every external side effect sits behind a provider interface bound at the composition root (delivery, model calls, clock-like effects). This is what let the pilot close a security-sensitive e2e gap as a binding-only change instead of a redesign (CONF-02); it is also what the gated harness profile needs, so an inline-instantiated effect is unreachable by e2e. Stated in the edition README; review each new external effect for it.
• Operational settings are configuration, not code (CFG-1). Non-secret settings resolve from committed config, secrets from the secret store; the architecture test bans a literal registry (model ids, provider endpoints) in host source and scripts. When the product gains a new operational-setting shape, extend the registry at D-000 rather than letting it pass.
• Harness completeness is self-auditing (TEST-2). Every public method of every client data service needs a scenario through the real transport, and the harness fails on an uncovered method, so write the scenario with the method, not after the interrogation. Where a scenario needs a seam the server does not expose, the ruled shape is the gated non-production harness profile: re-bind provider interfaces at the composition root under Harness:Enabled, which refuses to boot outside Development/Testing; never a weakening of a production path.

The ledger

Append every human turn to the repo's turn ledger the moment it happens: number, what happened, why a human was needed, provisional bucket. Feed every turn to intake as it happens, not only defects; intake's classification governs. A count held in your context is not a count (MET-05).

Exit

Green is never declared in prose. When every tier passes and the contract is met, invoke slice-exit and produce the report. If the report cannot be completed honestly, the slice is not green.

What this skill must NOT produce

• Nothing before the lock is on record; a phase started without its gate is a methodology violation the exit report must surface.
• No hand-authored prototype-fidelity tests (they derive from the lock; claim-driven tests keep their test-first shape).
• No invented UI for service methods the locked portion does not surface (CONF-03: record the boundary instead).
• No commits without explicit direction. No kernel fixes.