@telora/daemon 0.20.53 → 0.20.57

package/dist/resolver-dispatch.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Resolver-dispatch seam: attempt a blockage with a capable resolver BEFORE
+ * any human escalation can be filed.
+ *
+ * This is the generalization of the dirty-worktree advance-block shape
+ * (delivery-advance-block.ts): a blockage is first handed to a resolver that
+ * holds reach the sandboxed worktree agent lacks; only after that resolver
+ * fails, or a bounded retry budget is exhausted, does the blockage become a
+ * human escalation. Escalation is the residue, not the reflex.
+ *
+ * The seam deliberately owns ONE thing -- the WHEN policy (attempt-first,
+ * bounded-retry, escalate-on-exhaustion) -- and nothing else. It creates no
+ * agent_escalations row, knows nothing about Supabase, the worktree, or teams.
+ * The caller supplies a resolver (with a DECLARED `reach`) and an `escalate`
+ * sink; the seam decides only when each fires. That keeps it a pure,
+ * deterministic decision path every blockage class can route through, and keeps
+ * "a resolver is attempted first" an invariant of the dispatch rather than a
+ * convention each call site re-implements (and forgets).
+ *
+ * Why a declared `reach` rather than "just try and see": the asymmetry between
+ * a resolver that can reach the blockage and the sandboxed agent that cannot is
+ * the whole reason some blockages are resolvable at all. Making reach an
+ * explicit, injectable property lets a call site (and a test) distinguish "no
+ * capable resolver exists for this blockage -> it is genuinely a human's" from
+ * "a resolver exists and failed" WITHOUT standing up a live host.
+ *
+ * NOT a classifier. The seam does not sort blockages into kinds up front;
+ * attempting resolution discovers the kind for free. Route first; the residue
+ * (what survives the attempt) is what a human or a state-hold then owns.
+ *
+ * @module resolver-dispatch
+ */
+/**
+ * The bounded-retry-vs-escalate policy primitive, extracted so the decision
+ * lives in exactly ONE place. `attempts` is the number of resolver attempts
+ * already spent; `budget` is the maximum permitted. Returns 'retry' while there
+ * is budget left, 'escalate' once it is spent.
+ *
+ * delivery-advance-block delegates its "re-wake the team again vs. file a
+ * human escalation" decision to this function so the dirty-worktree path and
+ * the general seam share one definition of the boundary (its former inline
+ * `state.attempts < budget`).
+ */
+export declare function nextResolverStep(attempts: number, budget: number): 'retry' | 'escalate';
+/**
+ * A resolver that can attempt to close a blockage. Its `reach` is DECLARED and
+ * injectable: a reach-less resolver is never attempted (there is nothing for it
+ * to close), so the blockage routes straight to escalation.
+ */
+export interface BlockageResolver {
+    /**
+     * Whether this resolver actually has the reach to close the blockage. When
+     * false, `attempt` is never called and the blockage escalates with reason
+     * 'no_reach'. This is the property that distinguishes "a capable resolver
+     * exists and failed" from "no capable resolver exists".
+     */
+    readonly reach: boolean;
+    /**
+     * Try to resolve the blockage on attempt number `attemptNumber` (1-based).
+     * Resolves `true` on success, `false` on a recoverable failure worth another
+     * attempt within budget. A thrown error is treated as a failed attempt (never
+     * a crash of the seam), so a resolver need not defend every path itself.
+     */
+    attempt(attemptNumber: number): Promise<boolean>;
+}
+/** Why a blockage escalated to a human, when it did. */
+export type EscalationReasonResidue = 'no_reach' | 'exhausted';
+/** The terminal outcome of dispatching a blockage through the seam. */
+export type BlockageOutcome = {
+    kind: 'resolved';
+    attempts: number;
+} | {
+    kind: 'escalated';
+    attempts: number;
+    reason: EscalationReasonResidue;
+};
+/** Collaborators for {@link dispatchBlockage}; all injectable for tests. */
+export interface DispatchDeps {
+    /** The reach-declaring resolver attempted before any escalation. */
+    resolver: BlockageResolver;
+    /**
+     * The escalation sink. Called AT MOST ONCE, and ONLY after the resolver has
+     * no reach or has exhausted its retry budget. The seam creates no row itself;
+     * the caller decides what an escalation is (an agent_escalations row, a state
+     * hold, a log line). The invariant the seam guarantees is that this never
+     * fires while the resolver still might succeed.
+     */
+    escalate: () => Promise<void>;
+    /**
+     * Bounded retry budget: the maximum number of resolver attempts. Coerced to a
+     * non-negative integer. A budget of 0 (or a reach-less resolver) means the
+     * blockage escalates without any attempt. There is no unbounded mode.
+     */
+    budget: number;
+}
+/**
+ * Dispatch a blockage: attempt the resolver first, retry within a bounded
+ * budget, and escalate only as the residue.
+ *
+ * Guarantees, all provable without a live host:
+ *  - A reach-capable resolver is attempted BEFORE `escalate` is ever called.
+ *  - `escalate` fires only after the resolver fails every attempt within budget
+ *    (reason 'exhausted') or has no reach (reason 'no_reach') -- never on the
+ *    first blockage while an attempt is still possible.
+ *  - The retry loop always terminates: it runs at most `budget` attempts.
+ */
+export declare function dispatchBlockage(deps: DispatchDeps): Promise<BlockageOutcome>;
+//# sourceMappingURL=resolver-dispatch.d.ts.map

package/dist/resolver-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-dispatch.d.ts","sourceRoot":"","sources":["../src/resolver-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,CAEvF;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACH,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAClD;AAED,wDAAwD;AACxD,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,WAAW,CAAC;AAE/D,uEAAuE;AACvE,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,uBAAuB,CAAA;CAAE,CAAC;AAE7E,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,QAAQ,EAAE,gBAAgB,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC,CAyBnF"}

package/dist/resolver-dispatch.js

@@ -0,0 +1,83 @@
+/**
+ * Resolver-dispatch seam: attempt a blockage with a capable resolver BEFORE
+ * any human escalation can be filed.
+ *
+ * This is the generalization of the dirty-worktree advance-block shape
+ * (delivery-advance-block.ts): a blockage is first handed to a resolver that
+ * holds reach the sandboxed worktree agent lacks; only after that resolver
+ * fails, or a bounded retry budget is exhausted, does the blockage become a
+ * human escalation. Escalation is the residue, not the reflex.
+ *
+ * The seam deliberately owns ONE thing -- the WHEN policy (attempt-first,
+ * bounded-retry, escalate-on-exhaustion) -- and nothing else. It creates no
+ * agent_escalations row, knows nothing about Supabase, the worktree, or teams.
+ * The caller supplies a resolver (with a DECLARED `reach`) and an `escalate`
+ * sink; the seam decides only when each fires. That keeps it a pure,
+ * deterministic decision path every blockage class can route through, and keeps
+ * "a resolver is attempted first" an invariant of the dispatch rather than a
+ * convention each call site re-implements (and forgets).
+ *
+ * Why a declared `reach` rather than "just try and see": the asymmetry between
+ * a resolver that can reach the blockage and the sandboxed agent that cannot is
+ * the whole reason some blockages are resolvable at all. Making reach an
+ * explicit, injectable property lets a call site (and a test) distinguish "no
+ * capable resolver exists for this blockage -> it is genuinely a human's" from
+ * "a resolver exists and failed" WITHOUT standing up a live host.
+ *
+ * NOT a classifier. The seam does not sort blockages into kinds up front;
+ * attempting resolution discovers the kind for free. Route first; the residue
+ * (what survives the attempt) is what a human or a state-hold then owns.
+ *
+ * @module resolver-dispatch
+ */
+/**
+ * The bounded-retry-vs-escalate policy primitive, extracted so the decision
+ * lives in exactly ONE place. `attempts` is the number of resolver attempts
+ * already spent; `budget` is the maximum permitted. Returns 'retry' while there
+ * is budget left, 'escalate' once it is spent.
+ *
+ * delivery-advance-block delegates its "re-wake the team again vs. file a
+ * human escalation" decision to this function so the dirty-worktree path and
+ * the general seam share one definition of the boundary (its former inline
+ * `state.attempts < budget`).
+ */
+export function nextResolverStep(attempts, budget) {
+    return attempts < budget ? 'retry' : 'escalate';
+}
+/**
+ * Dispatch a blockage: attempt the resolver first, retry within a bounded
+ * budget, and escalate only as the residue.
+ *
+ * Guarantees, all provable without a live host:
+ *  - A reach-capable resolver is attempted BEFORE `escalate` is ever called.
+ *  - `escalate` fires only after the resolver fails every attempt within budget
+ *    (reason 'exhausted') or has no reach (reason 'no_reach') -- never on the
+ *    first blockage while an attempt is still possible.
+ *  - The retry loop always terminates: it runs at most `budget` attempts.
+ */
+export async function dispatchBlockage(deps) {
+    const budget = Math.max(0, Math.floor(deps.budget));
+    // No capable resolver -> nothing to attempt; escalate as the residue.
+    if (!deps.resolver.reach) {
+        await deps.escalate();
+        return { kind: 'escalated', attempts: 0, reason: 'no_reach' };
+    }
+    let attempts = 0;
+    while (nextResolverStep(attempts, budget) === 'retry') {
+        attempts += 1;
+        let resolved = false;
+        try {
+            resolved = await deps.resolver.attempt(attempts);
+        }
+        catch {
+            // A thrown attempt is a failed attempt, not a seam crash.
+            resolved = false;
+        }
+        if (resolved)
+            return { kind: 'resolved', attempts };
+    }
+    // Budget spent, every attempt failed -> escalate as the residue.
+    await deps.escalate();
+    return { kind: 'escalated', attempts, reason: 'exhausted' };
+}
+//# sourceMappingURL=resolver-dispatch.js.map

package/dist/resolver-dispatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-dispatch.js","sourceRoot":"","sources":["../src/resolver-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAgB,EAAE,MAAc;IAC/D,OAAO,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC;AAClD,CAAC;AAoDD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,IAAkB;IACvD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAEpD,sEAAsE;IACtE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACzB,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QACtB,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAChE,CAAC;IAED,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,OAAO,gBAAgB,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,OAAO,EAAE,CAAC;QACtD,QAAQ,IAAI,CAAC,CAAC;QACd,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACnD,CAAC;QAAC,MAAM,CAAC;YACP,0DAA0D;YAC1D,QAAQ,GAAG,KAAK,CAAC;QACnB,CAAC;QACD,IAAI,QAAQ;YAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;IACtD,CAAC;IAED,iEAAiE;IACjE,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;IACtB,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AAC9D,CAAC"}

package/dist/resolver-reach.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Resolver reach is BOUNDED up front, and its out-of-worktree actions are ON
+ * THE RECORD. The negative branch of the resolver-dispatch seam
+ * (resolver-dispatch.ts).
+ *
+ * The resolver only closes anything if it holds reach the sandboxed worktree
+ * agent lacks (spawn-sandbox.ts documents that asymmetry: a git worktree bounds
+ * the branch but NOT the OS -- credentials to other machines, sibling repos, the
+ * operator's home are all reachable). That same reach, granted without a
+ * declared bound, is unattended credentialed action on hosts with nothing
+ * reviewing what it did: a resolver's host actions produce no diff and pass no
+ * review gate, unlike code changes. Today's paste-into-Claude-Code workaround at
+ * least happens with a human watching; removing the human removes that too.
+ *
+ * Two invariants, both provable without a live host:
+ *
+ *  1. REACH IS DECLARED IN ADVANCE, PER BLOCKAGE CLASS, and FAIL-CLOSED. A
+ *     resolver acts only within a bound declared before it runs ("this class may
+ *     restart a container on host H"); an action outside that bound is REFUSED,
+ *     not permitted-and-logged. An unrecognized or undeclared blockage class
+ *     yields NO reach -- never a default to broad reach. This follows the
+ *     spawn-sandbox.ts shape: explicit, fail-closed, declared rather than
+ *     ambient. Reach is a property of the declared grant, never inferred from
+ *     what an attempt happened to touch (a reach granted by outcome is not a
+ *     bound).
+ *
+ *  2. EVERY OUT-OF-WORKTREE ACTION IS RECORDED, durably and credential-free, on
+ *     the success, failure, AND throwing paths -- a failed unattended action is
+ *     exactly the one that must not vanish. The record identifies the blockage,
+ *     the action attempted, and its outcome. The sink is injectable (tests
+ *     capture records without a live host); the default writes a structured line
+ *     to the canonical daemon log, which is durable and human-reviewable.
+ *
+ * This module is NOT a second resolver and does not re-open the dispatch design.
+ * It supplies the reach `bound` that feeds `BlockageResolver.reach` and wraps a
+ * single host action so it is authorized against the bound and recorded --
+ * composing with dispatchBlockage, not rewriting it.
+ *
+ * @module resolver-reach
+ */
+/**
+ * A blockage class -- the unit at which reach is declared in advance. Stable,
+ * coarse identifiers (e.g. 'dirty_worktree', 'restart_container'), NOT
+ * per-incident strings: the grant is authored against the class, so the class
+ * must be knowable before any specific blockage occurs.
+ */
+export type BlockageClass = string;
+/**
+ * One host action a resolver may attempt OUTSIDE the worktree. `kind` and
+ * `target` are what the bound is checked against; `summary` is the
+ * human-readable line that lands in the record.
+ */
+export interface ResolverAction {
+    /** The blockage class this action serves (checked against its grant). */
+    blockageClass: BlockageClass;
+    /** Stable action-kind id (e.g. 'restart_container'), matched against the grant. */
+    kind: string;
+    /** The host/resource the action touches (e.g. 'host-H'), matched against the grant. */
+    target: string;
+    /** Human-readable description of what will be attempted. Author-controlled; never carry credentials here. */
+    summary: string;
+}
+/**
+ * A DECLARED grant: exactly what a blockage class is permitted to do, authored
+ * in advance. An action is authorized only if BOTH its kind and its target are
+ * listed. An empty `allowedActionKinds` or `allowedTargets` therefore grants no
+ * reach at all -- the fail-closed floor.
+ */
+export interface ReachGrant {
+    blockageClass: BlockageClass;
+    /** Action kinds this class may attempt. Empty => no reach. */
+    allowedActionKinds: readonly string[];
+    /** Targets (hosts/resources) this class may touch. Empty => no reach. */
+    allowedTargets: readonly string[];
+}
+/** The declared grants, keyed by blockage class. Injectable so tests supply their own. */
+export type ReachRegistry = ReadonlyMap<BlockageClass, ReachGrant>;
+/** The resolved reach bound for one blockage class. */
+export interface ReachBound {
+    blockageClass: BlockageClass;
+    /** True only when a grant is declared for this class with non-empty allowed kinds AND targets. */
+    reach: boolean;
+    /** The declared grant when reach is real; null when the class is undeclared or empty. */
+    grant: ReachGrant | null;
+}
+/** The decision of authorizing one action against a bound. */
+export type ReachDecision = {
+    authorized: true;
+} | {
+    authorized: false;
+    reason: string;
+};
+/**
+ * Resolve a blockage class to its declared reach bound. FAIL-CLOSED: an
+ * unrecognized/undeclared class -- or a declared grant that permits no kind or
+ * no target -- yields `reach: false` and `grant: null`. There is no path that
+ * defaults an unknown class to broad reach.
+ */
+export declare function resolveReachBound(blockageClass: BlockageClass, registry: ReachRegistry): ReachBound;
+/**
+ * Authorize a single action against a resolved bound. REFUSES (does not
+ * permit-and-log) when the bound has no reach, the action serves a different
+ * class than the bound, or the action's kind/target is outside the declared
+ * grant. A refusal means the action must NOT run.
+ */
+export declare function authorizeAction(bound: ReachBound, action: ResolverAction): ReachDecision;
+/** The terminal outcome of one recorded resolver action. */
+export type ResolverActionOutcome = 'success' | 'failure' | 'refused';
+/**
+ * A durable record of one out-of-worktree resolver action. Carries NO
+ * credential material by construction: only the blockage class, the action's
+ * kind/target/summary, the outcome, and a REDACTED free-text detail.
+ */
+export interface ResolverActionRecord {
+    blockageClass: BlockageClass;
+    action: {
+        kind: string;
+        target: string;
+        summary: string;
+    };
+    outcome: ResolverActionOutcome;
+    /** Redacted free-text detail (failure reason / refusal reason). Never raw secrets. */
+    detail?: string;
+    /** ISO timestamp the record was written. */
+    recordedAt: string;
+}
+/**
+ * The injectable record sink. Called on EVERY path -- success, failure,
+ * refusal, and throw. Tests supply a capturing sink; the default writes to the
+ * canonical daemon log. May be async; the runner awaits it.
+ */
+export type ResolverActionRecorder = (record: ResolverActionRecord) => void | Promise<void>;
+/**
+ * The default production recorder: a structured line in the canonical daemon
+ * log (~/.telora/daemon.log) -- durable, rotated, and human-reviewable after
+ * the fact, which is precisely what a diff-less host action otherwise lacks.
+ * The record's `detail` is already redacted before it arrives here, so this
+ * sink cannot leak credentials.
+ */
+export declare const logResolverAction: ResolverActionRecorder;
+/**
+ * Redact credential-shaped material from free-text before it enters a record.
+ * A record a human reviews must never itself become a credential leak, so this
+ * scrubs bearer/authorization values, `key=value` pairs whose key names a
+ * secret, and long opaque token blobs. Conservative and lossy on purpose --
+ * over-redaction is safe; under-redaction is the failure.
+ */
+export declare function redactResolverDetail(text: string): string;
+/** What a bounded action's `execute` reports back. */
+export interface ResolverExecuteResult {
+    /** True when the host action succeeded. */
+    ok: boolean;
+    /** Free-text detail (never pre-redacted -- the runner redacts it). */
+    detail?: string;
+}
+/** The terminal outcome of {@link runReachBoundedAction}. */
+export type ReachBoundedOutcome = {
+    outcome: 'success';
+} | {
+    outcome: 'failure';
+    detail?: string;
+} | {
+    outcome: 'refused';
+    reason: string;
+};
+/** Collaborators for {@link runReachBoundedAction}; all injectable for tests. */
+export interface ReachBoundedDeps {
+    /** The declared grants. Reach is resolved from here BEFORE the action runs. */
+    registry: ReachRegistry;
+    /** The record sink, called on every path. Defaults to {@link logResolverAction}. */
+    record?: ResolverActionRecorder;
+    /** Detail redactor. Defaults to {@link redactResolverDetail}. */
+    redact?: (text: string) => string;
+    /** Clock for `recordedAt`. Defaults to ISO-now. */
+    clock?: () => string;
+}
+/**
+ * Run one out-of-worktree resolver action within its declared bound, recording
+ * every path.
+ *
+ * Guarantees, all provable without a live host:
+ *  - The action is AUTHORIZED against the pre-declared bound FIRST. An action
+ *    outside the bound (or under an undeclared class) is REFUSED -- `execute` is
+ *    never called -- and the refusal is recorded.
+ *  - On execution, `success` or `failure` is recorded from the result.
+ *  - If `execute` THROWS, a `failure` record is written (via catch) BEFORE the
+ *    error propagates -- the failed unattended action never vanishes.
+ *  - The recorded `detail` is always redacted, so no credential material enters
+ *    the record regardless of the sink.
+ */
+export declare function runReachBoundedAction(deps: ReachBoundedDeps, action: ResolverAction, execute: () => Promise<ResolverExecuteResult>): Promise<ReachBoundedOutcome>;
+//# sourceMappingURL=resolver-reach.d.ts.map

package/dist/resolver-reach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-reach.d.ts","sourceRoot":"","sources":["../src/resolver-reach.ts"],"names":[],"mappings":"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"}

package/dist/resolver-reach.js

@@ -0,0 +1,168 @@
+/**
+ * Resolver reach is BOUNDED up front, and its out-of-worktree actions are ON
+ * THE RECORD. The negative branch of the resolver-dispatch seam
+ * (resolver-dispatch.ts).
+ *
+ * The resolver only closes anything if it holds reach the sandboxed worktree
+ * agent lacks (spawn-sandbox.ts documents that asymmetry: a git worktree bounds
+ * the branch but NOT the OS -- credentials to other machines, sibling repos, the
+ * operator's home are all reachable). That same reach, granted without a
+ * declared bound, is unattended credentialed action on hosts with nothing
+ * reviewing what it did: a resolver's host actions produce no diff and pass no
+ * review gate, unlike code changes. Today's paste-into-Claude-Code workaround at
+ * least happens with a human watching; removing the human removes that too.
+ *
+ * Two invariants, both provable without a live host:
+ *
+ *  1. REACH IS DECLARED IN ADVANCE, PER BLOCKAGE CLASS, and FAIL-CLOSED. A
+ *     resolver acts only within a bound declared before it runs ("this class may
+ *     restart a container on host H"); an action outside that bound is REFUSED,
+ *     not permitted-and-logged. An unrecognized or undeclared blockage class
+ *     yields NO reach -- never a default to broad reach. This follows the
+ *     spawn-sandbox.ts shape: explicit, fail-closed, declared rather than
+ *     ambient. Reach is a property of the declared grant, never inferred from
+ *     what an attempt happened to touch (a reach granted by outcome is not a
+ *     bound).
+ *
+ *  2. EVERY OUT-OF-WORKTREE ACTION IS RECORDED, durably and credential-free, on
+ *     the success, failure, AND throwing paths -- a failed unattended action is
+ *     exactly the one that must not vanish. The record identifies the blockage,
+ *     the action attempted, and its outcome. The sink is injectable (tests
+ *     capture records without a live host); the default writes a structured line
+ *     to the canonical daemon log, which is durable and human-reviewable.
+ *
+ * This module is NOT a second resolver and does not re-open the dispatch design.
+ * It supplies the reach `bound` that feeds `BlockageResolver.reach` and wraps a
+ * single host action so it is authorized against the bound and recorded --
+ * composing with dispatchBlockage, not rewriting it.
+ *
+ * @module resolver-reach
+ */
+import { createLogger } from './log.js';
+const log = createLogger({ module: 'resolver-reach' });
+/**
+ * Resolve a blockage class to its declared reach bound. FAIL-CLOSED: an
+ * unrecognized/undeclared class -- or a declared grant that permits no kind or
+ * no target -- yields `reach: false` and `grant: null`. There is no path that
+ * defaults an unknown class to broad reach.
+ */
+export function resolveReachBound(blockageClass, registry) {
+    const grant = registry.get(blockageClass) ?? null;
+    const reach = grant !== null &&
+        grant.allowedActionKinds.length > 0 &&
+        grant.allowedTargets.length > 0;
+    return { blockageClass, reach, grant: reach ? grant : null };
+}
+/**
+ * Authorize a single action against a resolved bound. REFUSES (does not
+ * permit-and-log) when the bound has no reach, the action serves a different
+ * class than the bound, or the action's kind/target is outside the declared
+ * grant. A refusal means the action must NOT run.
+ */
+export function authorizeAction(bound, action) {
+    if (!bound.reach || bound.grant === null) {
+        return { authorized: false, reason: `no declared reach for blockage class "${action.blockageClass}"` };
+    }
+    if (action.blockageClass !== bound.blockageClass) {
+        return {
+            authorized: false,
+            reason: `action serves class "${action.blockageClass}" but bound is for "${bound.blockageClass}"`,
+        };
+    }
+    if (!bound.grant.allowedActionKinds.includes(action.kind)) {
+        return { authorized: false, reason: `action kind "${action.kind}" is outside the declared bound for "${bound.blockageClass}"` };
+    }
+    if (!bound.grant.allowedTargets.includes(action.target)) {
+        return { authorized: false, reason: `target "${action.target}" is outside the declared bound for "${bound.blockageClass}"` };
+    }
+    return { authorized: true };
+}
+/**
+ * The default production recorder: a structured line in the canonical daemon
+ * log (~/.telora/daemon.log) -- durable, rotated, and human-reviewable after
+ * the fact, which is precisely what a diff-less host action otherwise lacks.
+ * The record's `detail` is already redacted before it arrives here, so this
+ * sink cannot leak credentials.
+ */
+export const logResolverAction = (record) => {
+    log.info('resolver action recorded', {
+        blockageClass: record.blockageClass,
+        actionKind: record.action.kind,
+        target: record.action.target,
+        summary: record.action.summary,
+        outcome: record.outcome,
+        ...(record.detail !== undefined ? { detail: record.detail } : {}),
+        recordedAt: record.recordedAt,
+    });
+};
+/**
+ * Redact credential-shaped material from free-text before it enters a record.
+ * A record a human reviews must never itself become a credential leak, so this
+ * scrubs bearer/authorization values, `key=value` pairs whose key names a
+ * secret, and long opaque token blobs. Conservative and lossy on purpose --
+ * over-redaction is safe; under-redaction is the failure.
+ */
+export function redactResolverDetail(text) {
+    return text
+        // Authorization: Bearer <token> / bearer <token>
+        .replace(/\b(bearer)\s+[A-Za-z0-9._\-+/=]+/gi, '$1 [REDACTED]')
+        // key=value / key: value where the key names a secret
+        .replace(/\b(authorization|api[_-]?key|secret|password|passwd|token|access[_-]?key|private[_-]?key|client[_-]?secret)\b(\s*[:=]\s*)("?)[^\s"']+\3/gi, '$1$2[REDACTED]')
+        // Long opaque token blobs (>=24 chars of token alphabet) not otherwise caught.
+        .replace(/\b[A-Za-z0-9._\-+/=]{24,}\b/g, '[REDACTED]');
+}
+/**
+ * Run one out-of-worktree resolver action within its declared bound, recording
+ * every path.
+ *
+ * Guarantees, all provable without a live host:
+ *  - The action is AUTHORIZED against the pre-declared bound FIRST. An action
+ *    outside the bound (or under an undeclared class) is REFUSED -- `execute` is
+ *    never called -- and the refusal is recorded.
+ *  - On execution, `success` or `failure` is recorded from the result.
+ *  - If `execute` THROWS, a `failure` record is written (via catch) BEFORE the
+ *    error propagates -- the failed unattended action never vanishes.
+ *  - The recorded `detail` is always redacted, so no credential material enters
+ *    the record regardless of the sink.
+ */
+export async function runReachBoundedAction(deps, action, execute) {
+    const record = deps.record ?? logResolverAction;
+    const redact = deps.redact ?? redactResolverDetail;
+    const clock = deps.clock ?? (() => new Date().toISOString());
+    const write = async (outcome, detail) => {
+        const entry = {
+            blockageClass: action.blockageClass,
+            action: { kind: action.kind, target: action.target, summary: action.summary },
+            outcome,
+            recordedAt: clock(),
+        };
+        if (detail !== undefined)
+            entry.detail = redact(detail);
+        await record(entry);
+    };
+    const bound = resolveReachBound(action.blockageClass, deps.registry);
+    const decision = authorizeAction(bound, action);
+    if (!decision.authorized) {
+        // Refused: the action is NOT executed. Record the refusal for the audit trail.
+        await write('refused', decision.reason);
+        return { outcome: 'refused', reason: decision.reason };
+    }
+    try {
+        const result = await execute();
+        if (result.ok) {
+            await write('success', result.detail);
+            return { outcome: 'success' };
+        }
+        await write('failure', result.detail);
+        return result.detail !== undefined
+            ? { outcome: 'failure', detail: redact(result.detail) }
+            : { outcome: 'failure' };
+    }
+    catch (err) {
+        // A throwing action is exactly the one whose record must not vanish.
+        const message = err instanceof Error ? err.message : String(err);
+        await write('failure', message);
+        throw err;
+    }
+}
+//# sourceMappingURL=resolver-reach.js.map

package/dist/resolver-reach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-reach.js","sourceRoot":"","sources":["../src/resolver-reach.ts"],"names":[],"mappings":"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"}

package/dist/resolvers/git-diff-against-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-diff-against-base.d.ts","sourceRoot":"","sources":["../../src/resolvers/git-diff-against-base.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,oGAAoG;AACpG,wBAAgB,kCAAkC,IAAI,IAAI,CAqCzD"}
+{"version":3,"file":"git-diff-against-base.d.ts","sourceRoot":"","sources":["../../src/resolvers/git-diff-against-base.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,oGAAoG;AACpG,wBAAgB,kCAAkC,IAAI,IAAI,CA2CzD"}

package/dist/resolvers/git-diff-against-base.js

@@ -1,5 +1,5 @@
 import { registerSourceResolver } from '../assembly-engine.js';
-import { getGitDiff, getDiffStatSummary, MAX_DIFF_BYTES } from './shared/git-diff.js';
+import { getGitDiff, getDeliveryDiff, getDiffStatSummary, MAX_DIFF_BYTES } from './shared/git-diff.js';
 import { createLogger } from '../log.js';
 const log = createLogger({ module: 'assembly-engine' });
 /**
@@ -19,7 +19,13 @@ export function registerGitDiffAgainstBaseResolver() {
         // (reviewed_through_sha) so a resumed reviewer sees only watermark..tip;
         // every other caller diffs against the integration branch.
         const baseBranch = context.diffBaseOverride ?? context.config.integrationBranch;
-        const diff = getGitDiff(context.worktreePath, baseBranch);
+        // For the watermark-override case the range is always ahead by construction,
+        // so a plain base...HEAD diff is correct. For the default integration base,
+        // use the delivery-diff resolver so a focus branch that has ALREADY merged
+        // (level with integration) still yields its work rather than an empty diff.
+        const diff = context.diffBaseOverride
+            ? getGitDiff(context.worktreePath, baseBranch)
+            : getDeliveryDiff(context.worktreePath, baseBranch);
         if (!diff.trim())
             return '';
         if (diff.length > MAX_DIFF_BYTES) {

package/dist/resolvers/git-diff-against-base.js.map

@@ -1 +1 @@
-{"version":3,"file":"git-diff-against-base.js","sourceRoot":"","sources":["../../src/resolvers/git-diff-against-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;AAGxD;;;;;GAKG;AACH,oGAAoG;AACpG,MAAM,UAAU,kCAAkC;IAChD,sBAAsB,CAAC,uBAAuB,EAAE,KAAK,EAAE,OAAwB,EAAmB,EAAE;QAClG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YAC1B,GAAG,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;YAC9D,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,wEAAwE;QACxE,yEAAyE;QACzE,2DAA2D;QAC3D,MAAM,UAAU,GAAG,OAAO,CAAC,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC;QAChF,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QAE1D,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YAAE,OAAO,EAAE,CAAC;QAE5B,IAAI,IAAI,CAAC,MAAM,GAAG,cAAc,EAAE,CAAC;YACjC,MAAM,IAAI,GAAG,kBAAkB,CAAC,OAAO,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;YAClE,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;YAChD,OAAO;gBACL,wBAAwB,UAAU,GAAG;gBACrC,EAAE;gBACF,8BAA8B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,qBAAqB,IAAI,CAAC,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,KAAK;gBACvH,EAAE;gBACF,kBAAkB;gBAClB,EAAE;gBACF,KAAK;gBACL,IAAI,CAAC,IAAI,EAAE;gBACX,KAAK;gBACL,EAAE;gBACF,SAAS;gBACT,SAAS;gBACT,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,CAAC;QAED,OAAO,wBAAwB,UAAU,oBAAoB,IAAI,UAAU,CAAC;IAC9E,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"git-diff-against-base.js","sourceRoot":"","sources":["../../src/resolvers/git-diff-against-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACvG,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;AAGxD;;;;;GAKG;AACH,oGAAoG;AACpG,MAAM,UAAU,kCAAkC;IAChD,sBAAsB,CAAC,uBAAuB,EAAE,KAAK,EAAE,OAAwB,EAAmB,EAAE;QAClG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YAC1B,GAAG,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;YAC9D,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,wEAAwE;QACxE,yEAAyE;QACzE,2DAA2D;QAC3D,MAAM,UAAU,GAAG,OAAO,CAAC,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC;QAChF,6EAA6E;QAC7E,4EAA4E;QAC5E,2EAA2E;QAC3E,4EAA4E;QAC5E,MAAM,IAAI,GAAG,OAAO,CAAC,gBAAgB;YACnC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,YAAY,EAAE,UAAU,CAAC;YAC9C,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QAEtD,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YAAE,OAAO,EAAE,CAAC;QAE5B,IAAI,IAAI,CAAC,MAAM,GAAG,cAAc,EAAE,CAAC;YACjC,MAAM,IAAI,GAAG,kBAAkB,CAAC,OAAO,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;YAClE,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;YAChD,OAAO;gBACL,wBAAwB,UAAU,GAAG;gBACrC,EAAE;gBACF,8BAA8B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,qBAAqB,IAAI,CAAC,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,KAAK;gBACvH,EAAE;gBACF,kBAAkB;gBAClB,EAAE;gBACF,KAAK;gBACL,IAAI,CAAC,IAAI,EAAE;gBACX,KAAK;gBACL,EAAE;gBACF,SAAS;gBACT,SAAS;gBACT,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,CAAC;QAED,OAAO,wBAAwB,UAAU,oBAAoB,IAAI,UAAU,CAAC;IAC9E,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/resolvers/index.d.ts

@@ -28,7 +28,7 @@
  * (FocusEngine.init) can list them in the startup log.
  */
 export declare function initResolvers(): string[];
-export { MAX_DIFF_BYTES, getGitDiff, getDiffStatSummary, getChangedFiles, getCommitsAhead } from './shared/git-diff.js';
+export { MAX_DIFF_BYTES, getGitDiff, getDiffStatSummary, getChangedFiles, getCommitsAhead, getGitDiffRange, getDiffStatRange, getChangedFilesRange, findDeliveryMergeCommit, resolveDeliveryDiffRange, getDeliveryDiff, } from './shared/git-diff.js';
 export { CRT_DUMP_BUDGET_CHARS, renderRealityTreeDump, FOCUS_REALITY_TREE_EMPTY_STATE, } from './shared/reality-tree.js';
 export type { RealityTreeRow, RealityTreeListResponse, RealityNodeRow, RealityEdgeRow, NodeListResponse, EdgeListResponse, } from './shared/reality-tree.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/resolvers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAyFH;;;;;;;;;GASG;AACH,wBAAgB,aAAa,IAAI,MAAM,EAAE,CAgBxC;AAGD,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,kBAAkB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACxH,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,8BAA8B,GAC/B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAyFH;;;;;;;;;GASG;AACH,wBAAgB,aAAa,IAAI,MAAM,EAAE,CAgBxC;AAGD,OAAO,EACL,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACxB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,8BAA8B,GAC/B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,0BAA0B,CAAC"}

package/dist/resolvers/index.js

@@ -125,6 +125,6 @@ export function initResolvers() {
     return keys;
 }
 // ── Shared public surface (re-exports for external consumers) ─────────
-export { MAX_DIFF_BYTES, getGitDiff, getDiffStatSummary, getChangedFiles, getCommitsAhead } from './shared/git-diff.js';
+export { MAX_DIFF_BYTES, getGitDiff, getDiffStatSummary, getChangedFiles, getCommitsAhead, getGitDiffRange, getDiffStatRange, getChangedFilesRange, findDeliveryMergeCommit, resolveDeliveryDiffRange, getDeliveryDiff, } from './shared/git-diff.js';
 export { CRT_DUMP_BUDGET_CHARS, renderRealityTreeDump, FOCUS_REALITY_TREE_EMPTY_STATE, } from './shared/reality-tree.js';
 //# sourceMappingURL=index.js.map