@dpeek/codeless 0.1.3 → 0.1.4

package/README.md

@@ -103,13 +103,14 @@ 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 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`. 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
+worktree, and Herdr's official Pi lifecycle authority and session reporter. 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`. Pi's active command context
+owns the live conversation identity. Codeless requires Herdr's official reporter
+but treats its native session-reference value as asynchronous restore metadata,
+not an activation prerequisite. 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
@@ -131,7 +132,13 @@ replaces the Pi session in the same pane. It preserves the planner name, applies
 the planner selection read and validated after the stream fast-forwards to the
 captured integration commit, then activates and verifies the replacement before
 sending `/change` after resources reload. The previous conversation is not copied; the
-journal and project files carry context.
+journal and project files carry context. The fresh planner reads repository guidance,
+its journal, and current direction first. It stops on wholly gated work, uses the
+latest numbered change only for active or ambiguous recovery, and reads older changes
+only for journal-linked unresolved decisions. After selecting an ungated candidate it
+reads relevant contracts and implementation; after a fast-forward it also rereads
+current direction and files affected by incoming commits, without mining deleted or
+historical documents for work.
 
 This uses Pi's `newSession({ setup, withSession })` command API, verified with
 Pi 0.85.1. Only the replacement context activates the selection and sends the
@@ -228,8 +235,10 @@ 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.
+Herdr's managed agent name. Activation verifies the names, process, lifecycle
+authority, and worktree without correlating Herdr's asynchronous restore
+reference to Pi's live session; 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
@@ -276,10 +285,11 @@ the integration checkout. Success releases the lock. Other branches and
 checkouts are untouched; no push is performed.
 
 Another lock owner causes a stop, without queuing or polling. Rebase conflicts
-or failed checks retain ownership. Resolve the existing failure, then rerun
-`land`; it verifies the recorded integration commit has not changed. To abandon
-a landing, inspect the owner/base and Git state before manually removing the
-lock. There is no automatic stale-lock removal or retry.
+or failed checks retain ownership. During conflict resolution, run focused checks
+when useful; rerun `land` for the configured full check, which it alone owns.
+It verifies the recorded integration commit has not changed. To abandon a landing,
+inspect the owner/base and Git state before manually removing the lock. There is
+no automatic stale-lock removal or retry.
 
 `next` is the session handoff's preparation command. It requires the stream's
 own clean worktree and latest numbered change, a full commit hash present in its

package/extension/planner.js

@@ -4,8 +4,6 @@ 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",
@@ -96,47 +94,28 @@ export default function plannerExtension(pi) {
           throw new Error("Herdr returned an invalid planner identity response");
         }
       };
-      const attempts = activation ? nativeSessionAttempts : 1;
-      for (let attempt = 0; attempt < attempts; attempt += 1) {
-        const agent = await plannerIdentity();
-        if (agent?.name !== expectedPlanner) {
-          throw new Error(
-            `Codeless planner identity is ${agent?.name ?? "missing"}, expected ${expectedPlanner}; exit this agent and run codeless open ${match[1]} from another Herdr shell`,
-          );
-        }
-        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 agent = await plannerIdentity();
+      if (agent?.name !== expectedPlanner) {
+        throw new Error(
+          `Codeless planner identity is ${agent?.name ?? "missing"}, expected ${expectedPlanner}; exit this agent and run codeless open ${match[1]} from another Herdr shell`,
+        );
+      }
+      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;
+      if (
+        agent.screen_detection_skipped !== true ||
+        session?.source !== "herdr:pi" ||
+        session.agent !== "pi"
+      ) {
+        throw new Error("Codeless planner requires Herdr's Pi lifecycle integration");
       }
       const activeTools = ctx.getSystemPromptOptions().selectedTools ?? [];
       const missing = requiredTools.filter((tool) => !activeTools.includes(tool));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dpeek/codeless",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "An attended planner and implementer workflow for parallel capability development",
   "homepage": "https://github.com/dpeek/codeless#readme",
   "bugs": {

package/prompts/change.md

@@ -5,11 +5,11 @@ 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.
+First read the repository guidance, `$1/planner.md`, and `$2`. Read `.codeless/config.json` to resolve the integration branch. Current direction is authoritative for candidate discovery: do not mine deleted or historical documents for work when it is clear. If `planner.md` shows no active work and current direction has no ungated worthwhile candidate, stop rather than reading more context.
 
-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.
+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. Read the latest numbered change only when active or ambiguous work needs recovery. Read an older numbered change only when `planner.md` identifies its unresolved decision as still relevant.
 
-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.
+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 select an ungated candidate from current direction, require a clean worktree with no commits outside the configured integration branch, and fast-forward to that branch. After fast-forwarding, reread `$2`, every file affected by incoming commits, and the affected contracts and implementation; do not mine deleted or historical documents. 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`:
 

package/prompts/commit.md

@@ -32,6 +32,6 @@ The next planner proposes one change and waits for the operator's `go`; this han
 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.
+- 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 focused checks when useful to validate a resolution, then run `codeless land <slug>` again to finish; `land` alone runs the configured full check. 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/spec/workflow.md

@@ -140,23 +140,23 @@ existing managed planner focuses it without installation or another prompt.
 The package-owned extension activates creation, reopening, and post-landing
 replacement. Before the first project prompt it requires the exact
 `<slug>-planner` Pi name, `<slug-with-hyphens-replaced>_planner` Herdr name,
-managed interactive readiness, matching foreground worktree, and the current
-native Pi session ID/file reported by Herdr's official Pi lifecycle integration.
-It verifies `approve_stream_change`, `dispatch_stream_implementer`,
-`rework_stream_implementer`, `finish_stream_implementer`, and `next_stream_change`
-are active. During replacement, an otherwise-valid previous native session
-reference receives a brief bounded synchronization wait; a wrong name, process,
-lifecycle source, or worktree fails immediately. Any binding that remains missing
-or incompatible stops visibly before `/change`. Activation never repairs names.
-The direct `planner` command is removed;
-recovery exits Pi deliberately and reopens from another Herdr shell.
+managed interactive readiness, matching foreground worktree, Herdr's official Pi
+lifecycle authority and reporter, and the active planner tools. A wrong name,
+process, lifecycle source, worktree, or tool set stops visibly before `/change`.
+Activation never repairs names. Pi's active command context owns the live
+conversation identity. Codeless requires Herdr's official session reporter but
+treats its native session-reference value as asynchronous restore metadata; it
+does not correlate that value with the active Pi session or wait for a changed
+value. The direct `planner` command is removed; recovery exits Pi
+deliberately and reopens from another Herdr shell.
 
 Pi session replacement keeps the managed process and Herdr name while changing
-its native conversation reference. Codeless revalidates that new binding before
-prompting the replacement. Implementers use the corresponding `_impl` and
-`-impl` names. Codeless loads its own extension explicitly; Herdr's official Pi
-integration supplies lifecycle and native-session reporting. This boundary was
-verified against Herdr 0.8.2 and Pi 0.85.1.
+its native conversation reference. Codeless revalidates the replacement's Pi
+name, selection, tools, and Herdr process/lifecycle/worktree binding before
+prompting it. Implementers use the corresponding `_impl` and `-impl` names.
+Codeless loads its own extension explicitly; Herdr's official Pi integration
+supplies lifecycle and native-session reporting. This boundary was verified
+against Herdr 0.8.2 and Pi 0.85.1.
 
 ## Dispatch and review
 
@@ -213,7 +213,8 @@ integration commit.
 If the integration branch advanced, landing rebases the single stream commit. It then
 rereads and runs the configured project check in the stream worktree, requires checks to
 leave the worktree clean, and fast-forwards the dedicated integration checkout. Only
-successful completion releases the lock.
+successful completion releases the lock. Conflict recovery may run focused checks to
+validate resolutions, but only `land` runs the configured full check after rebase.
 
 A lock owned by another stream stops landing without polling. A rebase conflict, failed
 check, or other error after acquisition retains this stream's lock for deliberate
@@ -234,7 +235,13 @@ validates the updated direction, prompts, and planner selection, and returns the
 session name and `/change` prompt. The extension replaces the Pi session in the same
 pane, preserves its name, activates the validated selection and planner identity, and
 only then sends the project prompt. Conversation history is not copied; the journal and
-project files carry durable context.
+project files carry durable context. The prompt first reads repository guidance, the
+journal, and current direction; it stops when work is wholly gated. It reads the latest
+numbered change only for active or ambiguous recovery and older changes only for
+journal-identified unresolved decisions. Current direction selects candidates before
+relevant contracts and implementation are inspected. After a baseline fast-forward, it
+rereads current direction plus files affected by incoming commits, affected contracts,
+and code, without mining deleted or historical documents for work.
 
 A cancelled or failed replacement stops for operator attention. Landing remains
 complete, and any successful preparation fast-forward remains applied. There is no
@@ -267,10 +274,8 @@ an approval source, or a recovery mechanism.
 ## Limits
 
 Codeless is attended and intentionally has no supervisor, project registry, queue,
-automatic landing retry, stale-lock recovery, or unattended approval. Planner startup
-reads every numbered change, and conflict recovery currently causes the configured
-landing check to run twice. Because the default state is ignored, `git clean -fdx` can
-delete it.
+automatic landing retry, stale-lock recovery, or unattended approval. Because the
+default state is ignored, `git clean -fdx` can delete it.
 
 The single-active-change rule and the requirement to dispatch only approved input still
 partly depend on planner instructions. Approval reconciles records and hashes but does