@dpeek/codeless 0.1.1 → 0.1.3

package/README.md

@@ -12,8 +12,11 @@ consumer application code. Its tests use independent temporary repositories.
 
 ## Installation
 
-Codeless requires Bun, Git, Herdr, and Pi. The scoped package is configured for
-public npm access. Once published, install it with either package manager:
+Codeless requires Bun, Git, Herdr, and Pi. Planner activation requires Herdr's
+official Pi lifecycle integration; install it with `herdr integration install pi`
+and restart existing Pi processes after updating it. The managed launch and
+session-replacement contract is verified against Herdr 0.8.2 and Pi 0.85.1.
+The scoped package is configured for public npm access. Once published, install it with either package manager:
 
 ```sh
 bun add --global @dpeek/codeless
@@ -91,20 +94,30 @@ The configured prompt directory provides `change.md`, `implement.md`,
 
 Path arguments are JSON-quoted. Each direction is `<directions>/<slug>.md`.
 The project owns prompt contents, approval rules, review criteria, and the
-transition from review to commit. Required prompts and directions must exist;
-the runner does not generate or copy project instructions.
+transition from review to commit. `codeless init` creates missing copies of the
+package's four generic starters, but never replaces existing prompt bytes.
+Review and commit those local prompt edits in the invoking checkout, then bring
+that commit onto the configured integration branch before creating streams.
+Required prompts and directions must exist for stream creation and opening.
 
 The package-owned planner extension activates every planner session. Before its
-first project prompt, it requires the exact `<slug>-planner` Pi name, establishes
-and verifies the `<slug>_planner` Herdr identity, and confirms `approve_stream_change`,
-`dispatch_stream_implementer`, and `next_stream_change` are active. Missing or
+first project prompt, it requires the exact `<slug>-planner` Pi name and verifies
+the `<slug>_planner` Herdr identity, managed interactive readiness, foreground
+worktree, and matching native session reference from Herdr's Pi lifecycle
+integration. It confirms `approve_stream_change`,
+`dispatch_stream_implementer`, `rework_stream_implementer`, `finish_stream_implementer`, and `next_stream_change` are active. Missing or
 incompatible activation, identity mismatch, or inactive tools stops before
-`/change`; global Pi extension installation is unnecessary.
+`/change`. During session replacement, activation allows a brief bounded wait for
+an otherwise-valid Herdr identity to publish the current native Pi reference;
+it never waits on a wrong name, process, lifecycle source, or worktree. Global
+installation of Codeless's extension is unnecessary.
 The approval tool has no arguments. Its extension derives the active
 `<slug>-planner` Pi session and passes it to the backing CLI, which requires it
-to match the worktree and branch. The CLI validates the clean current-integration
-baseline and proposal, exclusively creates the next monotonic `changes/NNN.md`,
-and records one hash-backed journal approval. Exact retries reconcile a missing
+to match the clean stream worktree and branch. That stream commit is the
+proposal's base; approval does not compare it with a concurrently advancing
+integration branch. The CLI validates the proposal, exclusively creates the next
+monotonic `changes/NNN.md`, and records one hash-backed journal approval. Landing
+later owns locked synchronization and any required rebase onto integration. Exact retries reconcile a missing
 file or journal step; conflicting state stops. Approval returns the numbered path
 but does not dispatch it. Dispatch uses the package executable, inherits the
 planner's worktree, and queues review only on success. Pi loads the extension
@@ -121,7 +134,7 @@ sending `/change` after resources reload. The previous conversation is not copie
 journal and project files carry context.
 
 This uses Pi's `newSession({ setup, withSession })` command API, verified with
-Pi 0.84.3. Only the replacement context activates the selection and sends the
+Pi 0.85.1. Only the replacement context activates the selection and sends the
 new prompt. Configuration changes take effect at the next role-session boundary,
 not during an active planner or implementer. Review and remediation therefore
 continue with their existing session's selection. Duplicate requests
@@ -157,8 +170,15 @@ planners or worktree shells are running.
   metrics/<slug>/NNN.json # dispatch/landing times and deduplicated implementer attempts
 ```
 
-Run `codeless init` once after configuring a project. It creates the shared state
-layout and the dedicated integration worktree at
+Run `codeless init` once after configuring a project. It creates missing generic
+`change.md`, `implement.md`, `review.md`, and `commit.md` starters in the
+configured in-project prompt directory, reporting each as created or preserved.
+Existing prompt files are never replaced; review and commit generated files from
+the editable invoking checkout, then bring that commit onto the configured
+integration branch before creating streams. Init refuses to generate missing
+prompts when invoked from the dedicated integration checkout.
+
+It also creates the shared state layout and dedicated integration worktree at
 `<workspace>/worktree/<integration-branch>` without requiring Herdr. For the
 default workspace it adds only `/.codeless/state/` to the primary checkout's
 `.gitignore`; an absolute workspace override does not modify repository ignores.
@@ -172,36 +192,56 @@ inspect its targets before using it.
 
 ## Commands
 
-Run creation, opening, and planner launch from a Herdr-managed shell. Landing
-needs no Herdr session.
+Run creation and opening from a Herdr-managed operator shell outside the target
+planner/implementer panes. Herdr requires an available interactive shell in the
+target pane before it can start Pi. Landing needs no Herdr session.
 
 ```sh
 codeless init
 codeless create <slug>
 codeless open <slug>
-codeless planner <slug>
 codeless approve <planner-session>
 codeless dispatch <numbered-change-file>
+codeless rework <numbered-change-file> <feedback>
+codeless finish <numbered-change-file>
 codeless land <slug>
 codeless next <numbered-change-file> <landed-commit>
 codeless metrics
 ```
 
 Slugs are lowercase kebab-case, at most 24 characters. `init` validates the
-existing configuration and integration branch, reports the branch, primary
-checkout, workspace, and integration worktree, then creates only the shared
-state directories and canonical integration worktree when absent. All other
+existing configuration and integration branch, validates all configured prompt
+destinations before mutation, reports created or preserved starters plus the
+branch, primary checkout, workspace, and integration worktree, then creates the
+shared state directories and canonical integration worktree when absent. All other
 commands validate their prerequisites and never bootstrap this setup. `create` starts
 `stream/<slug>` from the integration branch and creates its local documents;
-it refuses existing streams. `open` resumes a stream. Both run the configured
-install command, then validate and open a planner beside an idle shell. `planner`
-starts Pi in an existing stream's lone shell after the same role preflight. Its
-activation establishes the same identity as creation and reopening.
+it refuses existing streams. `open` reuses the existing stream workspace and
+one- or two-pane layout. It focuses an existing managed planner without installing
+dependencies, sending another prompt, or replacing its conversation. To restart,
+exit Pi deliberately, leave both stream panes at their shell prompts in the
+stream worktree, then run `codeless open <slug>` from another Herdr shell.
+
+When a planner must be started, creation/opening validates the available shells,
+runs the configured install command and role preflight, adds a right-hand shell
+only when absent, and uses `herdr agent start` for named, readiness-checked Pi
+startup. It verifies the result before sending activation. An occupied or
+mismatched pane, unmanaged agent, ambiguous layout, or failed startup stops;
+Codeless never takes over an existing agent. Pi's display name is separate from
+Herdr's managed agent name. Activation verifies names and native session binding;
+it never renames an unmanaged process. There is no direct `planner` command.
+
 Dispatch validates the implementer selection before touching the planner's
 right-hand pane, starts a fresh ephemeral implementer with Codeless's reporting
-extension and its explicit Pi extension flag, and waits for completion. Its JSON
-result is a normalized attempt report, which the planner tool exposes before
-queueing review. It includes the actual settled model/thinking selection,
+extension and its explicit Pi extension flag, and waits for completion. Rework verifies
+that same change's idle implementer and worktree, invokes one package-owned Pi command
+that verifies its immutable stream/change scope, arms reporting, and submits one feedback
+turn with the same one-hour limit, records a `rework`
+attempt, and returns it before review is queued again. Finish verifies that identity,
+gracefully exits it, and waits for the right pane's stream-worktree shell. Neither operation
+replaces the agent, changes its selection, retries, or continues after a mismatch, timeout,
+blocked agent, or ambiguous pane. Its JSON result is a normalized attempt report, which the
+planner tool exposes before queueing review. It includes the actual settled model/thinking selection,
 terminal text and outcome, full-session Pi usage and available Pi cost estimate,
 timestamps, and tool/error counts; prompts, source, thinking, credentials, and
 transcripts are not retained.
@@ -216,11 +256,17 @@ integration fast-forward, Codeless records the landed time and commit on that
 change's canonical record, creating a landed record without elapsed time when
 dispatch collection was unavailable; collection warnings never alter dispatch or
 landing.
-`codeless metrics` prints every recorded stream and a project total. Its elapsed
-columns are dispatch-to-land wall-clock time; among landed changes, records
+`codeless metrics` prints every recorded stream and a project total. Its first
+table reports dispatch-to-land wall-clock time; among landed changes, records
 without a measured duration are explicitly unavailable. Dispatched-but-unlanded
-changes remain a separate count. Metrics are prospective local observations, not
-journal state or a recovery mechanism.
+changes remain a separate count. Its second table reports implementer attempts:
+distinct changes with rework, initial and rework turns, incomplete collection,
+exact stored terminal outcomes, and tool errors. Usage and cost coverage count
+measured attempts separately from unavailable collection; token totals include
+only measured usage, and cost totals remain grouped by recorded currency without
+conversion. These counts do not establish implementation quality or review
+success. Metrics are prospective local observations, not journal state or a
+recovery mechanism.
 
 Landing requires clean stream and integration worktrees and exactly one stream
 commit outside their merge base. It acquires `.land-lock` atomically, recording
@@ -248,8 +294,8 @@ control Pi itself. Preparation can be repeated safely after inspecting a failure
 
 If validation or session replacement fails, the planner stops for operator
 attention. Landing is already complete, and any preparation fast-forward remains
-applied. There is no background retry; restarting the planner recovers from the
-journal and Git state.
+applied. There is no background retry; exit Pi and reopen the stream from another
+Herdr shell to recover from the journal and Git state.
 
 ## Package development
 

package/extension/implementer-reporting.js

@@ -74,23 +74,89 @@ function write(path, value) {
 export default function implementerReportingExtension(pi) {
   pi.registerFlag("codeless-attempt", { type: "string" });
   let configuration;
+  let startupScope;
+  let rearm;
   let startedAt;
+  let entryOffset = 0;
   let toolCalls = 0;
   let errorCount = 0;
+
+  function configure(value, offset = 0) {
+    if (
+      typeof value?.path !== "string" ||
+      typeof value?.id !== "string" ||
+      typeof value?.stream !== "string" ||
+      typeof value?.change !== "string" ||
+      !["initial", "rework"].includes(value?.kind)
+    )
+      throw new Error("Codeless attempt configuration is invalid");
+    return { value, offset };
+  }
   pi.on("session_start", () => {
     try {
       const value = JSON.parse(pi.getFlag("codeless-attempt") ?? "");
-      if (
-        typeof value?.path === "string" &&
-        typeof value?.id === "string" &&
-        typeof value?.stream === "string" &&
-        typeof value?.change === "string"
-      )
-        configuration = value;
+      configuration = configure(value).value;
+      startupScope = { stream: configuration.stream, change: configuration.change };
     } catch {}
   });
+  function requireScope(value) {
+    if (
+      startupScope === undefined ||
+      value?.stream !== startupScope.stream ||
+      value?.change !== startupScope.change
+    )
+      throw new Error("Codeless stream/change scope does not match this implementer session");
+  }
+
+  pi.registerCommand("codeless-rework", {
+    description: "Submit one scope-verified Codeless implementer rework turn",
+    handler: async (args, ctx) => {
+      let value;
+      try {
+        value = JSON.parse(args);
+      } catch {
+        throw new Error("Codeless rework requires one JSON-quoted request");
+      }
+      requireScope(value);
+      if (typeof value?.feedback !== "string" || value.feedback.trim().length === 0)
+        throw new Error("Codeless rework requires concise non-empty feedback");
+      const next = configure(value, ctx.sessionManager.getEntries().length);
+      if (next.value.kind !== "rework") throw new Error("Codeless rework attempt must be rework");
+      configuration = undefined;
+      rearm = next;
+      try {
+        pi.sendUserMessage(`Review feedback: ${value.feedback.trim()}`, { deliverAs: "followUp" });
+      } catch (error) {
+        rearm = undefined;
+        throw error;
+      }
+    },
+  });
+
+  pi.registerCommand("codeless-finish", {
+    description: "Gracefully finish a scope-verified Codeless implementer",
+    handler: async (args, ctx) => {
+      let value;
+      try {
+        value = JSON.parse(args);
+      } catch {
+        throw new Error("Codeless finish requires one JSON-quoted scope");
+      }
+      requireScope(value);
+      await ctx.shutdown();
+    },
+  });
   pi.on("agent_start", () => {
-    startedAt ??= new Date().toISOString();
+    if (rearm !== undefined) {
+      configuration = rearm.value;
+      entryOffset = rearm.offset;
+      rearm = undefined;
+      startedAt = new Date().toISOString();
+      toolCalls = 0;
+      errorCount = 0;
+    } else {
+      startedAt ??= new Date().toISOString();
+    }
   });
   pi.on("tool_execution_end", (event) => {
     toolCalls += 1;
@@ -100,9 +166,10 @@ export default function implementerReportingExtension(pi) {
     if (configuration === undefined) return;
     const report = configuration;
     configuration = undefined;
-    const settledMessages = messages(ctx.sessionManager.getEntries());
+    const entries = ctx.sessionManager.getEntries().slice(entryOffset);
+    const settledMessages = messages(entries);
     const final = [...settledMessages].reverse().find((message) => message.role === "assistant");
-    const totals = sessionUsage(ctx.sessionManager.getEntries());
+    const totals = sessionUsage(entries);
     const model = final?.responseModel ?? final?.model ?? ctx.model?.id;
     const provider = final?.provider ?? ctx.model?.provider;
     const selection =
@@ -123,6 +190,7 @@ export default function implementerReportingExtension(pi) {
       stream: report.stream,
       change: report.change,
       role: "implementer",
+      kind: report.kind,
       startedAt: startedAt ?? new Date().toISOString(),
       endedAt: new Date().toISOString(),
       ...(selection === undefined ? {} : { selection }),

package/extension/planner.js

@@ -1,11 +1,16 @@
 import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
 import { validAttempt } from "../src/attempt.ts";
 
 const codeless = fileURLToPath(new URL("../bin/codeless", import.meta.url));
 const thinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const nativeSessionAttempts = 20;
+const nativeSessionRetryDelayMs = 50;
 const requiredTools = [
   "approve_stream_change",
   "dispatch_stream_implementer",
+  "rework_stream_implementer",
+  "finish_stream_implementer",
   "next_stream_change",
 ];
 
@@ -91,24 +96,47 @@ export default function plannerExtension(pi) {
           throw new Error("Herdr returned an invalid planner identity response");
         }
       };
-      let agent = await plannerIdentity();
-      if (agent?.name === "pi") {
-        const renamed = await pi.exec("herdr", ["agent", "rename", pane, expectedPlanner], {
-          timeout: 30_000,
-        });
-        if (renamed.code !== 0) {
+      const attempts = activation ? nativeSessionAttempts : 1;
+      for (let attempt = 0; attempt < attempts; attempt += 1) {
+        const agent = await plannerIdentity();
+        if (agent?.name !== expectedPlanner) {
           throw new Error(
-            renamed.stderr.trim() ||
-              renamed.stdout.trim() ||
-              "Codeless could not establish Herdr planner identity",
+            `Codeless planner identity is ${agent?.name ?? "missing"}, expected ${expectedPlanner}; exit this agent and run codeless open ${match[1]} from another Herdr shell`,
           );
         }
-        agent = await plannerIdentity();
-      }
-      if (agent?.name !== expectedPlanner) {
-        throw new Error(
-          `Codeless planner identity is ${agent?.name ?? "missing"}, expected ${expectedPlanner}`,
-        );
+        if (agent.agent !== "pi" || agent.interactive_ready !== true) {
+          throw new Error("Codeless requires a Herdr-managed Pi planner started by codeless open");
+        }
+        if (
+          typeof agent.foreground_cwd !== "string" ||
+          resolve(agent.foreground_cwd) !== resolve(ctx.cwd)
+        ) {
+          throw new Error("Codeless planner worktree does not match Herdr's foreground cwd");
+        }
+        const session = agent.agent_session;
+        const expectedSession =
+          session?.kind === "path"
+            ? ctx.sessionManager.getSessionFile()
+            : session?.kind === "id"
+              ? ctx.sessionManager.getSessionId()
+              : undefined;
+        if (
+          agent.screen_detection_skipped !== true ||
+          session?.source !== "herdr:pi" ||
+          session.agent !== "pi" ||
+          !expectedSession
+        ) {
+          throw new Error(
+            "Codeless planner native session does not match Herdr's Pi lifecycle integration",
+          );
+        }
+        if (session.value === expectedSession) break;
+        if (attempt === attempts - 1) {
+          throw new Error(
+            "Codeless planner native session does not match Herdr's Pi lifecycle integration",
+          );
+        }
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, nativeSessionRetryDelayMs));
       }
       const activeTools = ctx.getSystemPromptOptions().selectedTools ?? [];
       const missing = requiredTools.filter((tool) => !activeTools.includes(tool));
@@ -290,6 +318,98 @@ export default function plannerExtension(pi) {
       },
     });
 
+    pi.registerTool({
+      name: "rework_stream_implementer",
+      label: "Remediate stream implementation",
+      description:
+        "Reuse the idle implementer for this approved change, submit one actionable feedback turn, collect its rework attempt, and queue review again.",
+      promptSnippet: "Send one concise remediation request to the existing stream implementer",
+      promptGuidelines: [
+        "Call rework_stream_implementer only when review finds actionable defects in the approved change. Use its approved changePath and concise feedback; never reproduce Herdr commands.",
+        "The tool queues review only after a settled rework attempt. Stop on any error and do not retry automatically.",
+      ],
+      parameters: {
+        type: "object",
+        properties: {
+          changePath: {
+            type: "string",
+            description: "Absolute path to the approved changes/NNN.md file",
+          },
+          feedback: { type: "string", description: "Concise actionable review feedback" },
+        },
+        required: ["changePath", "feedback"],
+        additionalProperties: false,
+      },
+      async execute(_toolCallId, params, signal) {
+        const changePath = params.changePath.replace(/^@/, "");
+        const execution = await pi.exec("bun", [codeless, "rework", changePath, params.feedback], {
+          signal,
+          timeout: 3_700_000,
+        });
+        const output = [execution.stdout.trim(), execution.stderr.trim()]
+          .filter(Boolean)
+          .join("\n");
+        if (execution.code !== 0)
+          throw new Error(output || `codeless rework failed with exit code ${execution.code}`);
+        let attempt;
+        try {
+          attempt = JSON.parse(execution.stdout);
+        } catch {
+          throw new Error("Codeless returned an invalid rework attempt");
+        }
+        if (!validAttempt(attempt, attempt?.stream, attempt?.change) || attempt.kind !== "rework")
+          throw new Error("Codeless returned an invalid rework attempt");
+        pi.sendUserMessage(`/review ${JSON.stringify(changePath)}`, {
+          deliverAs: "steer",
+          expandPromptTemplates: true,
+        });
+        return {
+          content: [{ type: "text", text: attempt.text || "Implementer rework settled." }],
+          details: { changePath, attempt },
+        };
+      },
+    });
+
+    pi.registerTool({
+      name: "finish_stream_implementer",
+      label: "Finish stream implementer",
+      description:
+        "Gracefully exit the verified idle implementer after review approval and confirm its right-hand pane returned to the stream shell.",
+      promptSnippet: "Finish the approved stream implementer before commit and landing",
+      promptGuidelines: [
+        "Call finish_stream_implementer exactly once after recording review approval and before following commit-and-land instructions.",
+        "Stop on failure; do not use Herdr commands or continue to commit and land.",
+      ],
+      parameters: {
+        type: "object",
+        properties: {
+          changePath: {
+            type: "string",
+            description: "Absolute path to the approved changes/NNN.md file",
+          },
+        },
+        required: ["changePath"],
+        additionalProperties: false,
+      },
+      async execute(_toolCallId, params, signal) {
+        const changePath = params.changePath.replace(/^@/, "");
+        const execution = await pi.exec("bun", [codeless, "finish", changePath], {
+          signal,
+          timeout: 35_000,
+        });
+        const output = [execution.stdout.trim(), execution.stderr.trim()]
+          .filter(Boolean)
+          .join("\n");
+        if (execution.code !== 0)
+          throw new Error(output || `codeless finish failed with exit code ${execution.code}`);
+        return {
+          content: [
+            { type: "text", text: "Implementer exited and its pane returned to the stream shell." },
+          ],
+        };
+      },
+    });
+
     pi.registerTool({
       name: "dispatch_stream_implementer",
       label: "Dispatch stream implementer",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dpeek/codeless",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "An attended planner and implementer workflow for parallel capability development",
   "homepage": "https://github.com/dpeek/codeless#readme",
   "bugs": {
@@ -17,6 +17,7 @@
   "files": [
     "bin",
     "extension",
+    "prompts",
     "src",
     "README.md",
     "spec"

package/prompts/change.md

@@ -0,0 +1,40 @@
+---
+description: Propose and coordinate the next small change for a stream
+argument-hint: "<stream-directory> <direction-file>"
+---
+
+You are the planner for the stream at `$1`. The current working directory is the stream's repository worktree.
+
+Read the repository guidance, `.codeless/config.json`, `$1/planner.md`, every numbered Markdown file in `$1/changes/`, `$2`, its related contracts, and the current implementation relevant to the stream. Resolve the integration branch from that configuration.
+
+Before proposing, inspect the branch, recent commits, and worktree. If changes are not explained as an active approved change in `planner.md`, stop and show the operator the evidence. Never discard work automatically.
+
+If the latest numbered change is approved but uncommitted, resume it. If it is committed but unlanded on the configured integration branch, resume review or landing. Otherwise require a clean worktree with no commits outside the configured integration branch, fast-forward to that branch, and reread the direction and affected contracts. Stop on divergence. Once planning begins, keep that stream commit as the proposal's base; do not resynchronize merely because integration advances while the proposal awaits approval. Locked landing owns the later rebase.
+
+Propose exactly one small, complete change and write it to `$1/change.md`:
+
+```markdown
+# <short outcome>
+
+## Why
+
+## Change
+
+## Acceptance
+
+## Decisions
+```
+
+Under `Decisions`, record only choices that matter now; write `None` when there are none.
+
+Present the proposal and wait for the operator:
+
+- `go`: call `approve_stream_change` exactly once. It validates and promotes the proposal, records one approval, and returns its number, title, and absolute numbered change path. After it succeeds, call `dispatch_stream_implementer` exactly once with that returned change path.
+- `no`: append the rejected proposal and reason to `planner.md`; do not allocate a numbered change.
+- other feedback: revise `change.md`, recheck the relevant state, and present it again.
+
+Approval is separate from dispatch. Do not edit approval state by hand or reproduce the dispatch tool's worktree, pane, or agent operations. If dispatch returns an error, stop and show the operator the exact error; do not retry automatically.
+
+After the implementer settles, follow the queued `/review <absolute-numbered-change-path>` instruction. Do not finish after merely reporting that implementation settled. Keep this implementer alive for every remediation round belonging to the same numbered change.
+
+The implementation updates code, focused tests, owning contracts, and the direction; remove satisfied todo intentions. If no worthwhile work remains, say so.

package/prompts/commit.md

@@ -0,0 +1,37 @@
+---
+description: Commit one reviewed stream change
+argument-hint: "<numbered-change-file>"
+---
+
+Commit the reviewed implementation of `$1` on the current stream branch.
+
+Before committing or landing:
+
+- confirm `planner.md` records review approval for this change;
+- inspect the complete diff for unrelated edits;
+- confirm every acceptance criterion is met;
+- run the relevant checks if their passing result is not current;
+- determine whether this reviewed change already has its one commit because a previous landing attempt stopped.
+
+If the change is not committed, create exactly one commit. Use an imperative subject that describes the resulting behavior. Add a short body only for a non-obvious design decision. If the reviewed change already has its one unlanded commit, do not create another.
+
+Read `.codeless/config.json` to resolve the configured integration branch. Derive `<slug>` from the numbered change path and land it with:
+
+```sh
+codeless land <slug>
+```
+
+Replace the placeholder with the literal stream slug and do not include angle brackets. This command owns the shared integration lock, rebases the one stream commit when the configured integration branch advanced, runs the configured checks, and fast-forwards the dedicated integration checkout. It does not modify other branches or checkouts.
+
+If landing succeeds, append the full commit hash and subject plus a `landed on <configured-integration-branch>` note to the stream's `planner.md`. Include any decisions the next planner needs before resetting the session.
+
+Then call `next_stream_change` exactly once with `changePath` set to the absolute path of `$1` and `landedCommit` set to that full hash. Finish this turn after requesting the handoff. The tool validates the completed landing, fast-forwards the stream to the current configured integration branch, and starts a fresh planner session with the project's `/change` prompt. Do not propose the next change in this session or send `/new` through shell keystrokes.
+
+The next planner proposes one change and waits for the operator's `go`; this handoff does not approve further implementation. If no worthwhile work remains, it reports that and stops. If handoff validation fails or the reset is cancelled, stop and report the state; do not retry automatically. Landing remains complete even if the handoff fails.
+
+There are two expected landing stops:
+
+- If another stream owns the integration slot, leave this stream committed where it is, report the owner, and wait. Do not poll, queue, or retry automatically.
+- If this stream owns the slot and the rebase conflicts, keep the slot. Resolve the conflicts in this worktree so both the current configured integration branch and the approved change are preserved, stage the resolutions, and continue the rebase with `GIT_EDITOR=true git rebase --continue`. Repeat until the rebase completes, run the relevant checks, then run `codeless land <slug>` again to finish. The slot prevents another automated landing from moving the integration branch while you resolve it.
+
+For any other failure while this stream owns the slot, report the exact state and wait for the operator. The slot remains held for deliberate recovery; never remove the workspace's landing lock automatically or on guesswork.

package/prompts/implement.md

@@ -0,0 +1,17 @@
+---
+description: Implement one approved stream change
+argument-hint: "<numbered-change-file>"
+---
+
+You are the implementer. Implement only the approved change in `$1` in the current worktree.
+
+Read the numbered change, repository guidance, and the smallest relevant part of the codebase. Preserve unrelated work.
+
+- Do not edit the planner journal, current proposal, or numbered changes beside `$1`.
+- Do not commit, rebase, merge, switch branches, or reset files.
+- Update the owning contracts and todo with the implementation.
+- Add or update focused tests for changed behavior.
+- Run the smallest useful checks.
+- If the change cannot be completed safely, stop and explain the blocker with evidence.
+
+When finished, report what changed, checks run and their results, and assumptions or remaining concerns.

package/prompts/review.md

@@ -0,0 +1,20 @@
+---
+description: Review the worktree against one approved stream change
+argument-hint: "<numbered-change-file>"
+---
+
+You are the planner reviewing the implementation of `$1`.
+
+Read the approved change and repository guidance. Inspect the complete worktree diff and relevant surrounding code. Review for correctness and regressions, unmet acceptance criteria, missing or weak tests, accidental scope growth, and consistency with the repository's domain model and style.
+
+Run focused checks when the implementation report is insufficient evidence.
+
+If remediation is required, call `rework_stream_implementer` once with `$1` as `changePath` and a concise actionable feedback list. The tool reuses the verified idle implementer, waits for its one feedback turn, returns its rework attempt, and queues review again. Do not reproduce agent operations or retry automatically.
+
+If operator judgment is required, stop and ask one concrete question. If the change is ready:
+
+1. append a compact approval and verification summary to the stream's `planner.md`;
+2. call `finish_stream_implementer` once with `$1` as `changePath`; it gracefully exits the verified implementer and confirms its pane returned to the stream shell;
+3. only after that tool succeeds, read `.codeless/config.json`, resolve its `prompts` directory, and immediately follow that directory's `commit.md` instructions for `$1`.
+
+Do not finish the implementer before approval because remediation for this numbered change retains its context. If the finish tool fails, stop and report its error.