brainclaw 1.26.1 → 1.27.0

package/README.md

@@ -46,7 +46,7 @@ It sits alongside your coding agents and gives them a shared state layer they ca
 | **Agent-ready context**          | compact, prompt-sized context built from real workspace state instead of stale instructions                                                                                                         |
 | **Code Map**                     | a Tree-sitter symbol + import index (11 languages — JS/TS, Python, PHP, Java, Go, Rust, C#, Ruby, C, C++) so agents ask "where is X / what should I read first" before editing, with related decisions/traps attached — `bclaw_code_find` / `bclaw_code_brief`, see [code map](docs/code-map.md) |
 | **Native agent files**           | auto-writes `CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, `.cursor/rules/`, `.windsurfrules`, and similar local guidance                                                                         |
-| **Multi-turn loops**             | review and ideation loops with structured phases, iteration semantics, and per-phase memory filters — see[loop engine](docs/concepts/loop-engine.md) and [ideation loop](docs/concepts/ideation-loop.md) |
+| **Multi-turn loops**             | review, ideation, implementation, research, and debug workflows with structured phases, iteration semantics, verification gates, and per-phase memory filters — see [loop engine](docs/concepts/loop-engine.md) |
 | **Machine AI surface discovery** | detects local coding agents plus desktop AI work surfaces such as ChatGPT Desktop and Gemini CLI                                                                                                    |
 | **Queued surface tasks**         | stores project-scoped requests for other local AI surfaces, such as visual generation, drafting, summaries, or research                                                                             |
 | **Local-first storage**          | plain text + JSON, Git-friendly, no mandatory cloud, no telemetry by default                                                                                                                        |
@@ -263,14 +263,42 @@ bclaw_loop({ intent: "get", loop_id: "lop_abc" }); // inspect status any time
 
 ## The Loop Engine (Multi-Turn Workflows)
 
-Brainclaw's Loop Engine moves beyond manual ping-pong by formalizing multi-turn workflows (review, ideation, testing). It features two distinct review modes:
-
-- **Asymmetric Mode**: The classic author→reviewer handoff. The reviewer creates findings, and the original author must apply the fixes.
-- **Symmetric Mode**: Eliminates unnecessary round-trips. Both the author and reviewer slots can apply fixes directly, drastically speeding up spec and documentation reviews.
-
-Each loop maintains a structured lifecycle, explicit phases, iteration bounds, and per-phase memory filters, executed seamlessly via `bclaw_loop`.
-
-**Autonomous convergence (pln#628 Focus 4B + pln#630):** a dispatched reviewer doesn't need to be driven by hand. It writes its verdict (`review_verdict: approve | request_changes`) into its `LANE-RESULT.json`; when the coordinator harvests the lane, brainclaw records the verdict on the loop and **auto-closes it on approve** — the review loop reaches `reviewer_green` with no human ping-pong. On `request_changes`, brainclaw **runs the fix→re-review cycle autonomously**: it bumps the round, retains the worktree, and re-dispatches — through an exactly-once turn-attempt state machine (immutable attempt records behind an atomic launch fence, on by default; kill-switch `BRAINCLAW_TURN_OWNED_REVIEW=0`) so a turn is never double-spawned, with a bounded round cap that lands on `blocked` instead of looping forever.
+Brainclaw's Loop Engine formalizes repeated multi-turn work so agents can
+resume, automate, and audit it rather than relying on manual ping-pong. It is
+one engine with five shipped default workflows: **review, ideation,
+implementation, research, and debug**.
+
+| Workflow | Typical outcome | Normal entry point |
+| --- | --- | --- |
+| Review | accepted verdict or bounded fix cycle | `bclaw_coordinate(intent="review", open_loop=true)` |
+| Ideation | memory-confronted plan draft or synthesis | `bclaw_coordinate(intent="ideate")` |
+| Implementation | green verification and handoff | `bclaw_loop(intent="open", kind="implementation", allow_orphan=true)`, then `bind` |
+| Research | evidence-backed synthesis | `bclaw_loop(intent="open", kind="research", allow_orphan=true)` |
+| Debug | reproduced, verified fix and handoff | `bclaw_loop(intent="open", kind="debug", allow_orphan=true)` |
+
+Every loop has structured phases, bounded iteration, explicit artifacts, and
+per-phase memory filters. The shared controls are `open`, `turn`,
+`complete_turn`, `advance`, `add_artifact`, `pause`, `resume`, and `close`;
+implementation also adds `bind` and `verify`. `request_input` /
+`provide_input` are cross-cutting clarification primitives for any workflow.
+
+Every worker-backed phase, across all five workflows, is launched from one
+immutable [execution contract](docs/concepts/execution-contract.md): exact
+identity, artifact expectations, workspace policy, capability snapshot and
+evidence rules are persisted before the launch fence crosses. This reuses the
+existing TurnReservation, Assignment and AgentRun records; it does not add a
+second event journal.
+
+Gate-driving artifacts are also bound to a server-sealed
+[evidence envelope](docs/concepts/evidence-attestations.md). Review approval,
+command verification, claim binding, and ordinary observations are separate
+attestations rather than one confidence score; the same policy mechanism
+protects every workflow above.
+
+Review is a useful specialized path, not the definition of the engine. It has
+asymmetric and symmetric modes and can auto-close on an approved verdict; the
+other workflows use the same lifecycle to converge on a plan, synthesis,
+handoff, or verified fix. See the [Loop Engine guide](docs/concepts/loop-engine.md).
 
 ## Enterprise Ready: Mono-repo & Micro-services
 
@@ -310,7 +338,7 @@ Recent releases have moved a lot of multi-agent parallel work from "risky" to "s
 
 - **Per-claim auto-worktree** — each dispatched lane gets its own isolated git worktree; the coordinator integrates with an octopus merge.
 - **Sequenced parallel execute** — `bclaw_dispatch(intent="execute")` fans out independent lanes across several agent instances and integrates the result.
-- **Symmetric review-fix loops** — `bclaw_coordinate(intent="review", open_loop=true, review_mode="symmetric")` runs an alternating review-and-fix conversation across two slots without shared-checkout collisions. The reviewer's verdict is harvested from `LANE-RESULT.json` and the loop **auto-closes on approve** — no manual round-trip to converge the approve path.
+- **Loop Engine protocols** — review, ideation, implementation, research, and debug workflows share a persisted lifecycle. Review offers a symmetric auto-fix shortcut; implementation and debug bind verification to the work; ideation and research converge on durable syntheses.
 - **Cross-platform spawn** — OS-aware prompt delivery (stdin pipe / inline arg) plus a brief-ack file handshake, so spawned workers can be detected and timed out reliably on Windows and Unix.
 - **Worktree GC is scope-bounded** — symlinks and junctions are no longer followed during cleanup, so post-merge sweeps can't wipe `node_modules` or other neighboring directories.
 - **MCP runtime self-heal** — when the runtime is corrupted, the server logs an actionable repair pointer; `brainclaw doctor --repair` rebuilds dist in one step.
@@ -327,8 +355,9 @@ Recommended use today:
 
 1. for parallel work, dispatch a sequence with `bclaw_dispatch(intent="execute")` — each lane gets its own worktree
 2. for sequential work in the same project, let one agent claim at a time and rely on handoffs
-3. when reviewing or fixing across agents, prefer symmetric review loops over manual ping-pong
-4. keep multi-machine workflows on a single source of truth until federation lands
+3. choose the loop by outcome: ideation for a plan, implementation or debug for a verified handoff, research for a synthesis, and review for a verdict
+4. when reviewing or fixing across agents, prefer symmetric review loops over manual ping-pong
+5. keep multi-machine workflows on a single source of truth until federation lands
 
 ---
 

package/dist/cli/register-coordination.js

@@ -388,7 +388,7 @@ export function registerCoordinationCommands(program) {
     // --- loop (drive loop turn verbs; pln#517 step 2) ---
     const loopCmd = program
         .command('loop')
-        .description('Drive a loop turn (turn / complete-turn / advance / add-artifact)');
+        .description('Drive loop turns, fenced takeovers, phase advances, and artifacts');
     loopCmd
         .command('turn <loop_id>')
         .description('Issue a turn assignment on a slot')
@@ -407,6 +407,13 @@ export function registerCoordinationCommands(program) {
         .description('Complete a slot turn')
         .requiredOption('--slot <slot_id>', 'Target slot id (lsl_...)')
         .requiredOption('--outcome <outcome>', 'Turn outcome: done, failed, or cancelled')
+        .option('--assignment-id <id>', 'Attempt fence: stable assignment id')
+        .option('--turn-id <id>', 'Attempt fence: stable logical turn id')
+        .option('--run-id <id>', 'Attempt fence: physical run id')
+        .option('--nonce <value>', 'Attempt fence: generation launch nonce')
+        .option('--attempt-epoch <n>', 'Attempt fence: non-negative generation epoch')
+        .option('--execution-contract-hash <sha256>', 'Attempt fence: execution contract hash')
+        .option('--workspace-digest <sha256>', 'Attempt fence: canonical workspace digest')
         .option('--failure-reason <text>', 'Reason when outcome is failed')
         .option('--artifact <json>', 'JSON object payload for an artifact to attach')
         .option('--json', 'Machine-readable output')
@@ -415,6 +422,24 @@ export function registerCoordinationCommands(program) {
         const { runLoopCommand } = await import('../commands/loop.js');
         await runLoopCommand('complete-turn', { loop_id }, options, globalOpts.cwd);
     });
+    loopCmd
+        .command('takeover <loop_id>')
+        .description('Fence the active physical run and arm a fresh generation')
+        .requiredOption('--slot <slot_id>', 'Target slot id (lsl_...)')
+        .requiredOption('--turn-id <turn_id>', 'Stable logical turn id')
+        .requiredOption('--expected-epoch <n>', 'Currently active generation epoch')
+        .requiredOption('--cause <text>', 'Audited takeover cause')
+        .requiredOption('--liveness-evidence <text>', 'Evidence that the prior producer cannot safely continue')
+        .requiredOption('--external-effect-policy <policy>', 'none, idempotent, or externally_fenced')
+        .requiredOption('--next-workspace-path <path>', 'Existing isolated workspace for the new generation')
+        .requiredOption('--agent <agent>', 'Loop coordinator identity')
+        .option('--mode <mode>', 'takeover or retry', 'takeover')
+        .option('--json', 'Machine-readable output')
+        .action(async (loop_id, options) => {
+        const globalOpts = program.opts();
+        const { runLoopCommand } = await import('../commands/loop.js');
+        await runLoopCommand('takeover', { loop_id }, options, globalOpts.cwd);
+    });
     loopCmd
         .command('advance <loop_id>')
         .description('Advance a loop to its next phase')
@@ -441,6 +466,45 @@ export function registerCoordinationCommands(program) {
         const { runLoopCommand } = await import('../commands/loop.js');
         await runLoopCommand('add-artifact', { loop_id }, options, globalOpts.cwd);
     });
+    // --- attempt-authority (two-release writer guard; P4) ---
+    const attemptAuthorityCmd = program
+        .command('attempt-authority')
+        .description('Prepare, acknowledge and activate AttemptAuthority v2 writer compatibility');
+    attemptAuthorityCmd
+        .command('status')
+        .option('--json', 'Machine-readable output')
+        .action((options) => {
+        const globalOpts = program.opts();
+        return import('../commands/attempt-authority.js').then(({ runAttemptAuthorityCommand }) => runAttemptAuthorityCommand('status', { ...options, cwd: globalOpts.cwd }));
+    });
+    attemptAuthorityCmd
+        .command('prepare')
+        .requiredOption('--writers <agent_ids...>', 'Complete Release-A writer membership (registered agent ids)')
+        .option('--membership-epoch <n>', 'Membership epoch; defaults to active+1')
+        .option('--prepared-by <actor>', 'Audited operator/coordinator identity', 'operator')
+        .option('--json', 'Machine-readable output')
+        .action((options) => {
+        const globalOpts = program.opts();
+        return import('../commands/attempt-authority.js').then(({ runAttemptAuthorityCommand }) => runAttemptAuthorityCommand('prepare', { ...options, cwd: globalOpts.cwd }));
+    });
+    attemptAuthorityCmd
+        .command('ack')
+        .requiredOption('--membership-epoch <n>', 'Prepared membership epoch')
+        .requiredOption('--agent-id <agent_id>', 'Writer signing this ACK')
+        .option('--json', 'Machine-readable output')
+        .action((options) => {
+        const globalOpts = program.opts();
+        return import('../commands/attempt-authority.js').then(({ runAttemptAuthorityCommand }) => runAttemptAuthorityCommand('ack', { ...options, cwd: globalOpts.cwd }));
+    });
+    attemptAuthorityCmd
+        .command('activate')
+        .requiredOption('--membership-epoch <n>', 'Fully acknowledged membership epoch')
+        .option('--activated-by <actor>', 'Audited operator/coordinator identity', 'operator')
+        .option('--json', 'Machine-readable output')
+        .action((options) => {
+        const globalOpts = program.opts();
+        return import('../commands/attempt-authority.js').then(({ runAttemptAuthorityCommand }) => runAttemptAuthorityCommand('activate', { ...options, cwd: globalOpts.cwd }));
+    });
     // --- reply (provide_input to an operator_question; pln#508 step 4) ---
     program
         .command('reply <qst_id>')

package/dist/commands/attempt-authority.js

@@ -0,0 +1,80 @@
+import { loadAgentIdentity, loadAgentSigningKey } from '../core/agent-registry.js';
+import { loadConnectionState } from '../core/federation-state.js';
+import { ATTEMPT_AUTHORITY_WRITER_VERSION, activateAttemptAuthorityV2, attemptRolloutActivationDigest, ensureLocalAuthorityHome, prepareAttemptAuthorityRollout, publishAttemptRolloutAck, readLocalAuthorityHome, resolveActiveAttemptRollout, } from '../core/loops/attempt-rollout.js';
+function epoch(value, fallback = 1) {
+    const parsed = value === undefined ? fallback : Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0)
+        throw new Error('membership epoch must be a positive integer');
+    return parsed;
+}
+function print(value, json) {
+    if (json)
+        console.log(JSON.stringify(value, null, 2));
+    else
+        console.log(typeof value === 'string' ? value : JSON.stringify(value, null, 2));
+}
+export function runAttemptAuthorityCommand(subcommand, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (subcommand === 'status') {
+        const active = resolveActiveAttemptRollout(cwd);
+        print({
+            writer_version: ATTEMPT_AUTHORITY_WRITER_VERSION,
+            local_authority_home: readLocalAuthorityHome(cwd),
+            active,
+        }, options.json);
+        return;
+    }
+    if (subcommand === 'prepare') {
+        const writerIds = options.writers ?? [];
+        if (writerIds.length === 0)
+            throw new Error('prepare requires at least one --writers <agent_id>');
+        const participants = writerIds.map((writerId) => {
+            const identity = loadAgentIdentity(writerId, cwd);
+            if (!identity.identity_key) {
+                throw new Error(`agent ${writerId} has no Ed25519 identity key; re-register it before preparing rollout`);
+            }
+            return {
+                writer_id: writerId,
+                public_key_pem: identity.identity_key.public_key,
+                key_fingerprint: identity.identity_key.fingerprint,
+                status: 'active',
+            };
+        });
+        const active = resolveActiveAttemptRollout(cwd);
+        const membershipEpoch = epoch(options.membershipEpoch, (active?.guard.membership_epoch ?? 0) + 1);
+        const connection = loadConnectionState(cwd);
+        const home = ensureLocalAuthorityHome(cwd, { device_id: connection?.device.device_id });
+        const guard = prepareAttemptAuthorityRollout(cwd, {
+            membership_epoch: membershipEpoch,
+            authority_home: home,
+            participants,
+            previous_activation_digest: active ? attemptRolloutActivationDigest(active.activation) : undefined,
+            prepared_by: options.preparedBy ?? 'operator',
+        });
+        print(guard, options.json);
+        return;
+    }
+    if (subcommand === 'ack') {
+        const writerId = options.agentId;
+        if (!writerId)
+            throw new Error('ack requires --agent-id <agent_id>');
+        const signing = loadAgentSigningKey(writerId);
+        if (!signing)
+            throw new Error(`no local Ed25519 signing key for ${writerId}`);
+        const ack = publishAttemptRolloutAck(cwd, {
+            membership_epoch: epoch(options.membershipEpoch),
+            writer_id: writerId,
+            writer_version: ATTEMPT_AUTHORITY_WRITER_VERSION,
+            private_key_pem: signing.privateKeyPem,
+        });
+        print(ack, options.json);
+        return;
+    }
+    if (subcommand === 'activate') {
+        const activation = activateAttemptAuthorityV2(cwd, epoch(options.membershipEpoch), options.activatedBy ?? 'operator');
+        print(activation, options.json);
+        return;
+    }
+    throw new Error(`unknown attempt-authority subcommand: ${subcommand}`);
+}
+//# sourceMappingURL=attempt-authority.js.map

package/dist/commands/harvest.js

@@ -24,54 +24,33 @@ import { getCapabilityProfile, dispatchCanCommit } from '../core/agent-capabilit
 import { commitWorktreeOnBehalf, worktreesBaseDir, resolveGitToplevel } from '../core/worktree.js';
 import { closeReviewLoopFromLaneResult } from '../core/review-loop-close.js';
 import { closeIdeationLoopFromLaneResult } from '../core/ideation-loop-close.js';
-import { dispatchReviewLoopTurn, turnOwnedReviewEnabled } from '../core/review-loop-turn-dispatch.js';
+import { dispatchReviewLoopTurn, turnOwnedLoopEnabled } from '../core/review-loop-turn-dispatch.js';
 import { reconcileTurn } from '../core/loops/reconcile-turn.js';
 import { findReservationByAssignmentId } from '../core/loops/attempt-reservation.js';
+import { resolveTurnGenerationChain } from '../core/loops/attempt-generations.js';
 import { getLoop } from '../core/loops/store.js';
+import { phasePolicy } from '../core/loops/kind-policies.js';
 import { readCompletionSignals } from '../core/runtime-signals.js';
 import { reconcileClaimConformity } from '../core/claim-conformity.js';
 import { toWarningDetail } from '../core/warnings.js';
-/**
- * pln#630 PR3a — finalize a TURN-OWNED review lane via the exactly-once `reconcileTurn`
- * instead of the legacy `closeReviewLoopFromLaneResult`. Returns `undefined` for a legacy
- * (non-reserved) lane so the caller runs the unchanged legacy path — this is the
- * exactly-one-finalizer discriminator: a lane is turn-owned iff a reservation OWNS its
- * assignment_id (only the turn-owned dispatch writes a reservation file).
- *
- * Evidence sourcing (the load-bearing subtlety): a real reviewer's LANE-RESULT.json is
- * KEYLESS — the review brief never asks the worker to echo turn_id/run_id/nonce — so
- * read-strict `reconcileTurn` (which matches lane.{turn_id,run_id,nonce} against the
- * attempt) would REJECT it. We source the keys authoritatively: turn_id + run_id are
- * deterministic from the reservation, and the NONCE — the non-derivable proof that THIS
- * launch generation actually ran — comes from the coordinator's completion SENTINEL
- * (written mechanically by the ack-wrapper with the launch-grant token). A caller/test
- * that already supplies keyed lanes is honored (lane.* wins); a stale generation's
- * sentinel carries the old token → still rejected, preserving the anti-stale guarantee.
- */
-/**
- * The turn-owned FINALIZATION discriminator (pln#630, review Finding 1). A lane finalizes via
- * the exactly-once reconcileTurn ONLY if a committed reservation OWNS it AND turn-keyed evidence
- * (the nonce) is available — from the lane or the coordinator's completion SENTINEL. Without the
- * nonce, reconcileTurn's read-strict gate can NEVER converge: this is reachable in production
- * when a turn-owned dispatch WON the fence but did not ack-wrap-spawn (inbox_only / IDE-only
- * reviewer, command_ready_manual, capacity cap, BRAINCLAW_NO_SPAWN, worktree-creation failure) —
- * it minted a reservation but no sentinel will ever be written. Returning undefined there routes
- * the lane to the LEGACY presence-based closer so the loop still converges instead of stalling
- * forever. This is SAFE: the exactly-once SPAWN guarantee is enforced at DISPATCH by the launch
- * fence (already run), so using legacy FINALIZATION for a sentinel-less lane reintroduces no
- * double-spawn; and a sentinel that lands after a legacy close makes a later reconcile a
- * terminal-loop idempotent no-op.
- */
+import { harvestHarnessObservation } from '../core/harness-adapters/index.js';
 function turnOwnedLaneEvidence(lane, cwd) {
     const reservation = findReservationByAssignmentId(lane.assignment_id, cwd);
     if (!reservation)
         return undefined; // legacy lane (no reservation)
-    const nonce = lane.nonce ?? readCompletionSignals(cwd, reservation.child_ids.assignment_id).completed?.nonce;
-    if (!nonce)
-        return undefined; // reservation but NO turn-keyed evidence → legacy finalization
-    return { reservation, nonce };
+    const chain = resolveTurnGenerationChain(cwd, reservation.turn_id);
+    const completion = readCompletionSignals(cwd, reservation.child_ids.assignment_id, chain?.latest_generation.run_id).completed;
+    const nonce = lane.nonce ?? completion?.nonce;
+    if (!nonce && !reservation.execution_contract_ref)
+        return undefined;
+    return {
+        reservation,
+        nonce,
+        contract_hash: lane.execution_contract_hash ?? completion?.contract_hash,
+        capability_snapshot_hash: lane.capability_snapshot_hash ?? completion?.capability_snapshot_hash,
+    };
 }
-function reconcileTurnOwnedReviewLane(lane, cwd, evidence) {
+function reconcileTurnOwnedLane(lane, cwd, evidence) {
     const ev = evidence ?? turnOwnedLaneEvidence(lane, cwd);
     if (!ev)
         return undefined; // legacy lane OR no turn-keyed evidence — caller runs the legacy path
@@ -81,8 +60,17 @@ function reconcileTurnOwnedReviewLane(lane, cwd, evidence) {
         turn_id: lane.turn_id ?? reservation.turn_id,
         run_id: lane.run_id ?? reservation.child_ids.run_id,
         nonce,
+        execution_contract_hash: lane.execution_contract_hash ?? ev.contract_hash,
+        capability_snapshot_hash: lane.capability_snapshot_hash ?? ev.capability_snapshot_hash,
     };
-    const result = reconcileTurn({ turn_id: reservation.turn_id, lane: enrichedLane, cwd });
+    const loop = getLoop(reservation.loop_id, cwd);
+    const critiques = loop?.kind === 'ideation'
+        && reservation.phase === 'critique'
+        && lane.artifact_type === 'critique'
+        && (lane.body ?? '').trim().length > 0
+        ? [{ body: lane.body.trim() }]
+        : undefined;
+    const result = reconcileTurn({ turn_id: reservation.turn_id, lane: enrichedLane, cwd, critiques });
     return { reservation, result };
 }
 /**
@@ -392,15 +380,31 @@ export function harvestLaneResults(options = {}) {
     const worktreePaths = resolveLaneScanPaths(options, cwd);
     for (const worktreePath of worktreePaths) {
         const file = getLaneResultPath(worktreePath);
-        if (!fs.existsSync(file))
+        const fileExists = fs.existsSync(file);
+        let nativeObservation;
+        if (options.assignmentId) {
+            try {
+                nativeObservation = harvestHarnessObservation(options.assignmentId, cwd, !options.dryRun);
+            }
+            catch (err) {
+                result.errors.push(`Failed to harvest native harness output for ${options.assignmentId}: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+        }
+        if (!fileExists && !nativeObservation)
             continue;
         let lane;
-        try {
-            lane = LaneResultSchema.parse(JSON.parse(fs.readFileSync(file, 'utf-8')));
+        if (fileExists) {
+            try {
+                lane = LaneResultSchema.parse(JSON.parse(fs.readFileSync(file, 'utf-8')));
+            }
+            catch (err) {
+                result.errors.push(`Failed to parse ${file}: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
         }
-        catch (err) {
-            result.errors.push(`Failed to parse ${file}: ${err instanceof Error ? err.message : String(err)}`);
-            continue;
+        else {
+            lane = nativeObservation.lane;
         }
         // Assignment filter (when harvesting a specific lane).
         if (options.assignmentId && lane.assignment_id !== options.assignmentId)
@@ -438,14 +442,66 @@ export function harvestLaneResults(options = {}) {
                 // Kill-switch (=0), a legacy lane (no reservation), OR a reservation WITHOUT evidence
                 // (review Finding 1: an inbox_only/non-ack-wrapped dispatch that never wrote a
                 // sentinel) → the lane takes the unchanged legacy close so it still converges.
-                // Ideation stays legacy (review-only).
-                const laneTurnEvidence = turnOwnedReviewEnabled() ? turnOwnedLaneEvidence(lane, cwd) : undefined;
-                turnEvidenceForCatch = laneTurnEvidence;
+                // P0C: the same evidence gate now serves every LoopKind. Review keeps
+                // its report-only request_changes deferral because that path cannot
+                // re-dispatch a fix cycle; other kinds can safely record their result.
+                const candidateEvidence = turnOwnedLaneEvidence(lane, cwd);
+                // Set before reading the loop: a corrupt loop store may throw below,
+                // and the catch must still know this was a turn-owned lane to warn.
+                turnEvidenceForCatch = candidateEvidence;
+                const candidateLoop = candidateEvidence ? getLoop(candidateEvidence.reservation.loop_id, cwd) : undefined;
+                const laneTurnEvidence = candidateEvidence && candidateLoop && turnOwnedLoopEnabled(candidateLoop.kind)
+                    ? candidateEvidence
+                    : undefined;
+                turnEvidenceForCatch = laneTurnEvidence ?? candidateEvidence;
+                const ownedLoop = laneTurnEvidence ? candidateLoop : undefined;
+                const ownedPhasePolicy = ownedLoop
+                    ? phasePolicy(ownedLoop.kind, laneTurnEvidence.reservation.phase)
+                    : undefined;
                 if (!laneTurnEvidence) {
                     closeReviewLoopFromLaneResult(laneAssignment, lane, agent, cwd, { cycleOnRequestChanges: false });
                 }
+                else if (ownedPhasePolicy?.finalization === 'integrate') {
+                    result.warnings.push(toWarningDetail({
+                        code: 'loop_turn_not_converged',
+                        message: `Turn-owned ${ownedLoop?.kind ?? 'loop'} lane ${lane.assignment_id} requires harvest --integrate before convergence; claim retained.`,
+                        data: {
+                            assignment_id: lane.assignment_id,
+                            loop_id: laneTurnEvidence.reservation.loop_id,
+                            turn_id: laneTurnEvidence.reservation.turn_id,
+                            phase: laneTurnEvidence.reservation.phase,
+                        },
+                    }));
+                }
+                else if (ownedLoop?.kind !== 'review') {
+                    const rr = reconcileTurnOwnedLane(lane, cwd, laneTurnEvidence);
+                    if (ownedLoop?.kind === 'ideation'
+                        && laneTurnEvidence.reservation.phase === 'critique'
+                        && (lane.artifact_type !== 'critique' || !(lane.body ?? '').trim())) {
+                        result.warnings.push(toWarningDetail({
+                            code: 'loop_turn_not_converged',
+                            message: `Ideation critique lane ${lane.assignment_id} did not provide artifact_type='critique' with a non-empty body; no critique artifact was accepted.`,
+                            data: { assignment_id: lane.assignment_id, loop_id: laneTurnEvidence.reservation.loop_id, turn_id: laneTurnEvidence.reservation.turn_id },
+                        }));
+                    }
+                    if (rr && !rr.result.reconciled && !/superseded/.test(rr.result.reason ?? '')) {
+                        result.warnings.push(toWarningDetail({
+                            code: 'loop_turn_not_converged',
+                            message: `Turn-owned ${ownedLoop?.kind ?? 'loop'} lane ${lane.assignment_id} did not converge: ${rr.result.reason}.`,
+                            data: { assignment_id: lane.assignment_id, loop_id: laneTurnEvidence.reservation.loop_id, turn_id: laneTurnEvidence.reservation.turn_id },
+                        }));
+                    }
+                    if (ownedLoop?.kind === 'ideation' && rr) {
+                        ideationLoop = {
+                            loop_id: laneTurnEvidence.reservation.loop_id,
+                            action: rr.result.auto_closed ? 'closed' : rr.result.reconciled ? 'advanced' : 'noop',
+                            reason: rr.result.reason,
+                            loop_status: rr.result.loop_status,
+                        };
+                    }
+                }
                 else if (lane.review_verdict === 'approve') {
-                    const rr = reconcileTurnOwnedReviewLane(lane, cwd, laneTurnEvidence);
+                    const rr = reconcileTurnOwnedLane(lane, cwd, laneTurnEvidence);
                     // Reason-based quietness (PR #171 review P2-1 refinement): a terminal loop
                     // returns reconciled:true (idempotent no-op) and a superseded turn is the one
                     // healthy decline (`harvest --all` over a prior round's lane) — everything
@@ -465,7 +521,9 @@ export function harvestLaneResults(options = {}) {
                 }
                 // pln#521 P2-bis — the ideation analog: a critic lane records its critique +
                 // advances the ideation loop. Returns undefined for non-ideate scopes (no-op here).
-                ideationLoop = closeIdeationLoopFromLaneResult(laneAssignment, lane, agent, cwd);
+                if (!laneTurnEvidence) {
+                    ideationLoop = closeIdeationLoopFromLaneResult(laneAssignment, lane, agent, cwd);
+                }
                 // pln#636 C2 (review F3) — the universal net's most important trigger.
                 // A file-fallback worker declares its own footprint in `files_changed`,
                 // which is BOTH cheaper and more reliable than a git diff here: by
@@ -522,6 +580,8 @@ export function harvestLaneResults(options = {}) {
                         ideation_loop: ideationLoop ?? null,
                         files_changed: lane.files_changed ?? [],
                         source_worktree: worktreePath,
+                        harness_stdout_log: nativeObservation?.stdout_log ?? null,
+                        harness_stderr_log: nativeObservation?.stderr_log ?? null,
                     },
                 }, cwd);
                 fs.mkdirSync(path.dirname(marker), { recursive: true });
@@ -684,27 +744,46 @@ export function integrateLaneResults(options = {}) {
                 // next_turn) unless the iteration cap is hit. This is the --integrate
                 // path, so it MAY cycle (it can re-dispatch AND retain the claim). No-op
                 // for non-review lanes / lanes without a verdict; never throws.
-                // pln#521 P2-bis — the ideation analog (record critique + advance the ideation
-                // loop). Turn-owned is REVIEW-ONLY (pln#630), so ideation always uses the legacy
-                // path. It is independent of the review-loop close (a lane's scope is review-loop
-                // XOR ideate-loop), so it runs once here regardless of the branch below.
-                const ideationClose = closeIdeationLoopFromLaneResult(assignment, lane, actor, cwd);
-                if (ideationClose) {
-                    reasons.push(`ideate-loop ${ideationClose.loop_id}: ${ideationClose.action} — ${ideationClose.reason}`);
-                    entry.ideation_loop = ideationClose;
+                // Legacy ideation lanes still use the historical closer. A turn-owned
+                // lane of any kind is finalized exactly once by reconcileTurn below.
+                const candidateEvidence = turnOwnedLaneEvidence(lane, cwd);
+                const ownedLoop = candidateEvidence ? getLoop(candidateEvidence.reservation.loop_id, cwd) : undefined;
+                const turnOwnedEvidence = candidateEvidence && ownedLoop && turnOwnedLoopEnabled(ownedLoop.kind)
+                    ? candidateEvidence
+                    : undefined;
+                if (!turnOwnedEvidence) {
+                    const ideationClose = closeIdeationLoopFromLaneResult(assignment, lane, actor, cwd);
+                    if (ideationClose) {
+                        reasons.push(`ideate-loop ${ideationClose.loop_id}: ${ideationClose.action} — ${ideationClose.reason}`);
+                        entry.ideation_loop = ideationClose;
+                    }
                 }
                 // pln#630 PR3a — a TURN-OWNED review lane finalizes via the exactly-once
                 // reconcileTurn, which REPLACES the legacy closer + teardown gate for this lane
                 // (exactly-one finalizer per lane). Kill-switch (=0), a legacy (non-reserved) lane, OR a
                 // reservation with NO turn-keyed evidence (review Finding 1) → `turnOwned` is undefined
                 // and the unchanged legacy `else` block runs so the loop still converges.
-                const turnOwned = turnOwnedReviewEnabled()
-                    ? reconcileTurnOwnedReviewLane(lane, cwd)
+                const turnOwned = turnOwnedEvidence
+                    ? reconcileTurnOwnedLane(lane, cwd, turnOwnedEvidence)
                     : undefined;
                 if (turnOwned) {
                     const { reservation, result: rr } = turnOwned;
-                    entry.review_loop = reconcileToReviewLoopResult(reservation, rr, lane);
-                    reasons.push(`turn-owned reconcile ${reservation.loop_id}: ${entry.review_loop.action} — ${rr.reason}${rr.conflict ? ' [CONFLICT — held]' : ''}`);
+                    if (ownedLoop?.kind === 'review') {
+                        entry.review_loop = reconcileToReviewLoopResult(reservation, rr, lane);
+                        reasons.push(`turn-owned reconcile ${reservation.loop_id}: ${entry.review_loop.action} — ${rr.reason}${rr.conflict ? ' [CONFLICT — held]' : ''}`);
+                    }
+                    else {
+                        const action = rr.auto_closed ? 'closed' : rr.reconciled ? 'advanced' : 'noop';
+                        reasons.push(`turn-owned ${ownedLoop?.kind ?? 'loop'} reconcile ${reservation.loop_id}: ${action} — ${rr.reason}${rr.conflict ? ' [CONFLICT — held]' : ''}`);
+                        if (ownedLoop?.kind === 'ideation') {
+                            entry.ideation_loop = {
+                                loop_id: reservation.loop_id,
+                                action,
+                                reason: rr.reason,
+                                loop_status: rr.loop_status,
+                            };
+                        }
+                    }
                     // pln#630 PR3b — a symmetric request_changes bumped the round + retained the claim
                     // and handed back the next fix-cycle turn. Push it exactly like the legacy path so
                     // the existing async re-dispatch loop spawns round N+1 into the reused worktree. The

package/dist/commands/loop.js

@@ -60,6 +60,14 @@ function parseOutcome(opts) {
     }
     return outcome;
 }
+function parseOptionalEpoch(value, opts) {
+    if (value === undefined)
+        return undefined;
+    const epoch = Number(value);
+    if (!Number.isInteger(epoch) || epoch < 0)
+        fail('--attempt-epoch must be a non-negative integer', 1, opts);
+    return epoch;
+}
 function formatNextExpected(hint) {
     if (!hint)
         return '  (loop has no further expected action)';
@@ -95,11 +103,37 @@ function buildRequest(subcommand, loopId, opts) {
                 intent: 'complete_turn',
                 loop_id: loopId,
                 slot_id: requireOption(opts.slot, '--slot <slot_id>', opts),
+                assignment_id: opts.assignmentId,
+                turn_id: opts.turnId,
+                run_id: opts.runId,
+                nonce: opts.nonce,
+                attempt_epoch: parseOptionalEpoch(opts.attemptEpoch, opts),
+                execution_contract_hash: opts.executionContractHash,
+                workspace_digest: opts.workspaceDigest,
                 outcome: parseOutcome(opts),
                 failure_reason: opts.failureReason,
                 artifact,
             };
         }
+        case 'takeover': {
+            const epoch = Number(opts.expectedEpoch);
+            if (!Number.isInteger(epoch) || epoch < 0)
+                fail('--expected-epoch must be a non-negative integer', 1, opts);
+            return {
+                intent: 'takeover',
+                loop_id: loopId,
+                slot_id: requireOption(opts.slot, '--slot <slot_id>', opts),
+                turn_id: requireOption(opts.turnId, '--turn-id <turn_id>', opts),
+                expected_epoch: epoch,
+                cause: requireOption(opts.cause, '--cause <text>', opts),
+                liveness_evidence: requireOption(opts.livenessEvidence, '--liveness-evidence <text>', opts),
+                external_effect_policy: requireOption(opts.externalEffectPolicy, '--external-effect-policy <policy>', opts),
+                next_workspace_path: requireOption(opts.nextWorkspacePath, '--next-workspace-path <path>', opts),
+                takeover_mode: opts.mode,
+                agent: opts.agent,
+                agentId: opts.agent,
+            };
+        }
         case 'advance':
             return {
                 intent: 'advance',