peaks-loop 4.0.3 → 4.0.5

package/dist/services/dispatch/post-merge.js

@@ -0,0 +1,13 @@
+export function planMergeBack(input) {
+    if (input.agentBranch.length === 0)
+        return { kind: 'missing', reason: 'agent-branch-empty' };
+    if (input.callerBranch === input.agentBranch)
+        return { kind: 'noop' };
+    if (input.conflictingFiles.length > 0)
+        return { kind: 'conflict', conflictingFiles: input.conflictingFiles };
+    const base = ['git', 'merge', '--no-ff'];
+    if (input.callerBranch === 'main' && input.commitsBehind === 0) {
+        return { kind: 'fast-forward', command: ['git', 'merge', '--ff-only', input.agentBranch] };
+    }
+    return { kind: 'no-ff', command: [...base, input.agentBranch] };
+}

package/dist/services/dispatch/service-shutdown.d.ts

@@ -0,0 +1,22 @@
+export type ServiceRegistration = {
+    readonly pid: number;
+    readonly name: string;
+    readonly url?: string;
+};
+export type ServiceKillOutcome = {
+    readonly pid: number;
+    readonly name: string;
+    readonly skipped: false;
+    readonly signal: 'SIGTERM' | 'SIGKILL' | 'taskkill';
+};
+export type ServiceKillSkipped = {
+    readonly pid: number;
+    readonly name: string;
+    readonly skipped: true;
+    readonly reason: 'not-running';
+};
+export type ServiceKillResult = ServiceKillOutcome | ServiceKillSkipped;
+export declare function killRegisteredServices(input: {
+    readonly registrations: ReadonlyArray<ServiceRegistration>;
+    readonly platform?: NodeJS.Platform;
+}): ReadonlyArray<ServiceKillResult>;

package/dist/services/dispatch/service-shutdown.js

@@ -0,0 +1,51 @@
+/**
+ * service-shutdown — best-effort kill helper for sub-agent-registered
+ * local services.
+ *
+ * Slice 2026-08-01-subagent-merge-and-e2e (Task 3). The parent session
+ * reads `.peaks/_runtime/<sid>/dispatch/<dispatchId>/service-registrations.json`
+ * (written by `peaks sub-agent shutdown register --pid <pid> --name <label>`)
+ * and calls `killRegisteredServices` BEFORE the merge-back step so a
+ * long-lived `vite dev` / mock-API / docker-proxy process started by the
+ * sub-agent does not block the merge (file lock, port collision, dirty
+ * db, etc).
+ *
+ * The helper is intentionally minimal:
+ *   - pid <= 0 or pid === process.pid → skip (`not-running`).
+ *   - win32: `taskkill /T /F /PID <pid>` (force, with subtree).
+ *   - POSIX: `kill -TERM <pid>`; on failure escalate to `kill -KILL`.
+ *   - any error → `not-running` (best-effort; the parent will retry
+ *     merge regardless).
+ *
+ * All native calls are best-effort and never throw; the orchestrator
+ * (merge-back-runner.ts) just records the array of outcomes on the
+ * dispatch record's `serviceKill` field (added in Task 7).
+ */
+import { execFileSync } from 'node:child_process';
+export function killRegisteredServices(input) {
+    const platform = input.platform ?? process.platform;
+    return input.registrations.map((reg) => {
+        if (reg.pid <= 0 || reg.pid === process.pid) {
+            return { pid: reg.pid, name: reg.name, skipped: true, reason: 'not-running' };
+        }
+        try {
+            if (platform === 'win32') {
+                execFileSync('taskkill', ['/T', '/F', '/PID', String(reg.pid)], { stdio: 'ignore' });
+                return { pid: reg.pid, name: reg.name, skipped: false, signal: 'taskkill' };
+            }
+            // POSIX: try SIGTERM via the `kill` CLI (universally available);
+            // escalate to SIGKILL on failure. The runner is best-effort.
+            try {
+                execFileSync('kill', ['-TERM', String(reg.pid)], { stdio: 'ignore' });
+            }
+            catch {
+                execFileSync('kill', ['-KILL', String(reg.pid)], { stdio: 'ignore' });
+                return { pid: reg.pid, name: reg.name, skipped: false, signal: 'SIGKILL' };
+            }
+            return { pid: reg.pid, name: reg.name, skipped: false, signal: 'SIGTERM' };
+        }
+        catch {
+            return { pid: reg.pid, name: reg.name, skipped: true, reason: 'not-running' };
+        }
+    });
+}

package/dist/services/hooks/presence-marker-detector.js

@@ -46,15 +46,23 @@ function readPresenceFile(absolutePath) {
     try {
         raw = readFileSync(absolutePath, 'utf8');
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
+    catch (err) { // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
+        if (err instanceof ReferenceError)
+            throw err; // surface module-load bugs
+        if (err instanceof SyntaxError)
+            throw err; // surface parse bugs
+        return null; // only swallow IO errors
     }
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
+    catch (err) { // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
+        if (err instanceof ReferenceError)
+            throw err; // surface module-load bugs
+        if (err instanceof SyntaxError)
+            throw err; // surface parse bugs
+        return null; // only swallow IO errors
     }
     if (parsed === null || typeof parsed !== 'object')
         return null;

package/dist/services/hooks/worktree-authorization-gate.d.ts

@@ -104,6 +104,8 @@ export type WorktreeAuthDenyCode =
 /** Slice 2026-07-29-worktree-l2-extended Part 19: container
  * lease id is set but the lease file is unreadable / malformed. */
  | 'CONTAINER_LEASE_FILE_INVALID'
+/** Host Agent/Task worktree isolation was not issued by Peaks dispatch. */
+ | 'HOST_AGENT_ISOLATION_UNMANAGED'
 /** Container lease exists but is not active (status != 'active' OR past expiresAt). */
  | 'CONTAINER_LEASE_NOT_ACTIVE'
 /** Container lease exists but its rid does not match the current peaks request. */
@@ -139,6 +141,8 @@ export type WorktreeAuthCheckInput = {
      * is active and its rid matches.
      */
     readonly containerLeaseId: string | null;
+    /** Peaks-issued provenance token required for host Agent/Task worktree isolation. */
+    readonly dispatchProvenanceToken?: string | null;
 };
 /** Stable identifier of the current "user authorization" — derived from session + tool + key args. */
 export declare function currentAuthFingerprint(input: WorktreeAuthCheckInput): string;

package/dist/services/hooks/worktree-authorization-gate.js

@@ -36,6 +36,7 @@ import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { deserializeLease, isLeaseActive, leaseFilePath, } from '../worktree/worktree-lease.js';
+import { readDispatchProvenance } from '../worktree/dispatch-provenance.js';
 import { containerLeaseFilePath, deserializeContainerLease, isContainerLeaseActive, } from '../container/container-lease.js';
 export const WORKTREE_AUTH_FILE = 'worktree-auth.json';
 /** Stable identifier of the current "user authorization" — derived from session + tool + key args. */
@@ -232,6 +233,27 @@ export function decideFromAuthorization(input, operation, file) {
  */
 export function evaluateWorktreeAuth(input) {
     const operation = classifyToolCall(input);
+    if (operation === 'agent-isolation-worktree') {
+        const token = input.dispatchProvenanceToken ?? '';
+        const provenance = token.length > 0
+            ? readDispatchProvenance({ projectRoot: input.projectRoot, sessionId: input.sessionId, token })
+            : null;
+        if (provenance === null ||
+            input.leaseId === null ||
+            provenance.leaseId !== input.leaseId ||
+            (input.requestId !== null && provenance.requestId !== input.requestId)) {
+            return {
+                allow: false,
+                code: 'HOST_AGENT_ISOLATION_UNMANAGED',
+                reason: 'Host Agent/Task worktree isolation lacks a matching Peaks dispatch provenance record and canonical lease.',
+                remediation: 'Route the work through Peaks sub-agent dispatch with worktree isolation. Existing leaked host worktrees must be reconciled or adopted before cleanup.'
+            };
+        }
+        const leaseDecision = decideFromLease({ ...input, requestId: provenance.requestId });
+        if (!leaseDecision.allow)
+            return leaseDecision;
+        return leaseDecision;
+    }
     if (operation === null) {
         // Pass-through (Read, Glob, etc., and any Bash that isn't worktree-mutating).
         return {

package/dist/services/skills/skill-statusline-renderer.d.ts

@@ -1,6 +1,89 @@
 import type { StatusLineModel } from './skill-statusline-service.js';
 /**
- * Render the status line. The output is plain text with simple status glyphs so
- * it stays readable in any terminal; Claude Code applies its own styling.
+ * Pure formatting layer for the Peaks statusLine. Takes the read-only status
+ * model and produces the single line Claude Code paints at the bottom of the
+ * terminal. Kept separate from the reader so formatting can be tested without
+ * touching the filesystem.
+ *
+ * Capability-aware rendering: three glyph palettes are kept side by side in
+ * {@link PALETTES} so the switch from "active" / "idle" / "warning" to a
+ * concrete string happens in one place. Adding a fourth capability (e.g. for
+ * a future IDE) is a one-table change.
  */
-export declare function renderStatusLine(model: StatusLineModel): string;
+export type StatusLineCapability = 'ansi-unicode' | 'unicode' | 'ascii';
+export interface StatusLineRenderOptions {
+    readonly capability: StatusLineCapability;
+}
+/**
+ * Resolve the capability tier from environment and TTY state. Pure and
+ * deterministic — no I/O beyond reading the caller-supplied `env` and
+ * `isTTY` flag. The CLI delegates to this so the read-only status line
+ * does not need to know about ANSI/NO_COLOR semantics.
+ *
+ * The optional `forced` argument is a TEST SEAM (consumed by direct unit
+ * tests, not by the CLI). It lets tests pin a tier without constructing a
+ * TTY/NO_COLOR fixture. The CLI does NOT expose any flag that maps to
+ * `forced` — the env-driven path is the single first-version runtime
+ * source of truth.
+ *
+ * Adapter-internal env override (NOT a user-facing CLI flag):
+ *   `PEAKS_STATUSLINE_ASCII` — when set to `1` / `true` / `yes`, the
+ *   renderer drops to the ASCII palette (no Unicode-extra glyphs, no ANSI).
+ *   This is an adapter-internal mechanism for the trust boundary described
+ *   by the two-forms-only / human-NL-choice-only tenets: the user never
+ *   types a CLI verb to flip palettes, but the adapter (and only the
+ *   adapter) can set the env var on the user's behalf when its consumer
+ *   (e.g. a tiny terminal without UTF-8) needs ASCII. We do NOT expose
+ *   this via a CLI flag.
+ *
+ * Order of resolution (highest priority first):
+ *
+ *   1. `forced` argument (test seam only)
+ *   2. `PEAKS_STATUSLINE_ASCII` set → `ascii` (adapter-internal override)
+ *   3. `isTTY === true` → `ansi-unicode`
+ *   4. otherwise → `unicode` (still ANSI-colored; only `ascii` is color-free)
+ *
+ * Why this ordering: the IDE statusline invokes the renderer through a
+ * hook that may not always be detected as a TTY. The `unicode` tier
+ * now emits the cyan brand accent + semantic colors so the line reads
+ * as a branded product surface whether or not the consumer is a
+ * terminal. `NO_COLOR` is honored as an ambient convention by the
+ * IDE adapter (which can set `PEAKS_STATUSLINE_ASCII=1` to opt out
+ * fully), so a separate tier for NO_COLOR is no longer needed.
+ *
+ * `ascii` is the strict no-color, no-Unicode-extra tier; it is the
+ * single safe option for plain log / file consumers.
+ *
+ * Why `PEAKS_STATUSLINE_ASCII` outranks `NO_COLOR`:
+ *   The two env vars are NOT redundant. `NO_COLOR` (https://no-color.org)
+ *   is the cross-industry signal that NO escape sequences should be emitted
+ *   — its only effect is "ANSI off". The Unicode-extra glyphs (●, █, ░, etc.)
+ *   are NOT ANSI escape sequences; they are UTF-8 characters and `NO_COLOR`
+ *   does not address them. `PEAKS_STATUSLINE_ASCII` is the adapter-internal
+ *   "signal source is a tiny terminal without UTF-8" override and drops the
+ *   glyphs to ASCII shape as well. Both are correct signals about
+ *   different concerns; the ASCII override wins because it is strictly
+ *   narrower (a tiny terminal needs both no-ANSI AND no-Unicode-extra).
+ *
+ * The deliberate ordering keeps the rendered text ANSI-free when the consumer
+ * is a logger, a file, or any non-interactive sink, and only enables ANSI
+ * under an explicit supported condition (TTY + no env veto).
+ */
+export declare function resolveStatusLineCapability(input: {
+    readonly env: NodeJS.ProcessEnv;
+    readonly isTTY: boolean;
+    readonly forced?: StatusLineCapability;
+}): StatusLineCapability;
+/**
+ * Render the status line. Pure — no I/O, no side effects. The output is
+ * a single short line suitable for the bottom-of-terminal status bar.
+ *
+ * The `options.capability` field selects the glyph palette. When omitted,
+ * the function falls back to `unicode` (no ANSI escape codes), preserving
+ * the legacy behaviour for the CLI's `peaks statusline` invocation.
+ *
+ * Compact-state precedence: when `model.compact.kind !== 'none'` the
+ * compact bar replaces the active/idle/stale content. The C1 baseline
+ * line is preserved when the compact state is `none`.
+ */
+export declare function renderStatusLine(model: StatusLineModel, options?: StatusLineRenderOptions): string;