@telora/daemon 0.21.12 → 0.21.81

package/dist/resolver-reach.js

@@ -1,168 +0,0 @@
-/**
- * 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

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

package/dist/retire-aware-restatement.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retire-aware-restatement.d.ts","sourceRoot":"","sources":["../src/retire-aware-restatement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AA0B/E;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,iBAAiB,CAAC,EAAE,mBAAmB,CAAC;IACxC;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAA6B,CAAC,EAAE,OAAO,CAAC;CACzC;AAyCD;;;;;;;;;;;;GAYG;AACH,wBAAsB,yCAAyC,CAC7D,MAAM,EAAE,MAAM,EACd,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,SAAS,CAAC;IAAC,6BAA6B,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1E,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAiGtC;AAED;;;;;;;;GAQG;AACH,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAuCpD"}

package/dist/retire-aware-restatement.js

@@ -1,231 +0,0 @@
-/**
- * Retire-aware FRT desired-effect prose authoring.
- *
- * DRAFT-ASSIST BACKSTOP -- NOT THE SOURCE OF TRUTH. The declared desired
- * effect, authored as intent at injection time via the `target` action, is the
- * source of truth. This path is an optional backstop for the completed-focus
- * tail: it authors prose ONLY when a declared desired effect is absent (the
- * node's `frt_statement` is blank) and NEVER overwrites a non-blank
- * `frt_statement`. Everything it writes is MARKED as a machine draft
- * (`frt_statement_drafted=true`) so a declared intent of record is always
- * distinguishable from loop-generated draft prose.
- *
- * The eager cascade-prose path (`cascade-restatement.ts`) authors `frt_statement`
- * by reading `reality_tree_derive_frt`, whose server handler loads ONLY
- * status='active' nodes. An injection retires (status='retired',
- * injectionStatus='verified') the moment its anchoring delivery verifies -- the
- * terminal state of every COMPLETED focus -- so derive_frt no longer sees it.
- * Any UDE that a close-loop sweep flipped with no supplied restatement is left
- * with its base `statement` unchanged (still the present-tense problem text) and
- * `frt_statement` null. The cascade path can never repair that hole because the
- * injection is gone from its active set.
- *
- * This module is the retire-aware authoring path. Given a tree it finds the UDEs
- * that VERIFIED/RETIRED injections flipped and authors any missing
- * `frt_statement` -- mirroring Ship Log Pass 2's intent (surface the realized
- * differential of a completed focus) but on the AUTHORING side.
- *
- * SOURCE OF THE INJECTION->UDE LINK. `reality_tree_verify_injection` DELETES an
- * injection's `targets` edges at retirement (graph-verification.ts:240-245), so
- * a completed focus retains NONE of them -- reading targets edges would find
- * zero. The only durable record is `reality_tree_node_history`
- * (injection_id, node_id, previous_statement), snapshotted at verify
- * (graph-verification.ts:347-353,383-391). We reach it through the existing
- * node-keyed `reality_tree_injection_history` action -- no new server action.
- *
- * Overlay-only: only `frt_statement` is written (matching the `frtStatement ??
- * statement` display contract); node_type and the base statement are untouched.
- *
- * Idempotent + safe: a candidate is authored only when (a) it is a
- * `desired_effect` node with a blank `frt_statement`, (b) a verified-injection
- * history row references it, and (c) its base `statement` still equals the
- * snapshotted pre-flip UDE text. (c) skips nodes whose base statement was
- * already promoted to positive prose at verify (a restatement was supplied), and
- * combined with (a) makes re-runs a no-op once `frt_statement` is written.
- *
- * Reuses `authorRestatement` (injection-conditioned) -- it does NOT duplicate the
- * prompt/model logic. Best-effort per node: a per-node failure is swallowed (that
- * node is recorded skipped) so one failure never aborts the tree.
- *
- * @module retire-aware-restatement
- */
-import { callApi as defaultCallApi } from './queries/shared.js';
-import { authorRestatement as defaultAuthorRestatement, needsRestatement, } from './de-restatement.js';
-/**
- * Gather the TREE-LEVEL verified/retired injection statements once, for the
- * provenance-free fallback. Unions injection nodes across `status:'active'` and
- * `status:'retired'` (retired injections are the norm on a completed focus) and
- * keeps only those with `injectionStatus==='verified'` and a non-blank
- * statement. Deduplicated. The SAME list conditions every fallback node on the
- * tree, mirroring `authorCascadeRestatements`. Read-only -- no model calls.
- */
-async function gatherTreeVerifiedInjectionStatements(treeId, callApi) {
-    const statements = new Set();
-    for (const nodeStatus of ['active', 'retired']) {
-        let resp;
-        try {
-            resp = await callApi('reality_tree_node_list', {
-                treeId,
-                nodeType: 'injection',
-                status: nodeStatus,
-            });
-        }
-        catch {
-            // Best-effort: a failed slice just contributes nothing to the union.
-            continue;
-        }
-        for (const n of resp.items ?? []) {
-            if (n.nodeType === 'injection' &&
-                n.injectionStatus === 'verified' &&
-                typeof n.statement === 'string' &&
-                n.statement.trim() !== '') {
-                statements.add(n.statement.trim());
-            }
-        }
-    }
-    return [...statements];
-}
-/**
- * Find the retire-aware authoring candidates for one tree: `desired_effect`
- * nodes with a blank `frt_statement` that a VERIFIED/RETIRED injection flipped
- * (per node history) and whose base `statement` is still the raw pre-flip UDE
- * text. Read-only -- no model calls, no writes. The dry-run preview and the
- * write path share this selection so they never diverge.
- *
- * When `includeProvenanceFreeFallback` is set, a blank `desired_effect` node
- * that is still problem-shaped but lacks any verified-injection history row is
- * ALSO returned, conditioned on the tree's verified/retired injection
- * statements (gathered once). The precise per-node history path still wins
- * whenever provenance exists; the fallback fires only in its absence.
- */
-export async function findRetiredInjectionRestatementCandidates(treeId, deps = {}) {
-    const callApi = deps.callApi ?? defaultCallApi;
-    const includeFallback = deps.includeProvenanceFreeFallback === true;
-    // Active nodes: a flipped UDE becomes an ACTIVE desired_effect node (the
-    // injection auto-flips node_type at verify; only crt_only nodes are retired).
-    const nodesResp = await callApi('reality_tree_node_list', {
-        treeId,
-        status: 'active',
-    });
-    const nodes = nodesResp.items ?? [];
-    // Cheap pre-filter: desired_effect nodes still missing positive overlay prose.
-    const preCandidates = nodes.filter((n) => n.nodeType === 'desired_effect' && needsRestatement(n.frtStatement));
-    // Tree-level injection statements for the fallback -- gathered lazily ONCE,
-    // only if the flag is on AND at least one node falls through to the fallback.
-    let treeInjectionStatements = null;
-    const treeStatements = async () => {
-        if (treeInjectionStatements === null) {
-            treeInjectionStatements = await gatherTreeVerifiedInjectionStatements(treeId, callApi);
-        }
-        return treeInjectionStatements;
-    };
-    const candidates = [];
-    for (const node of preCandidates) {
-        let history = null;
-        try {
-            history = await callApi('reality_tree_injection_history', {
-                nodeId: node.id,
-            });
-        }
-        catch {
-            // No durable history reachable -> cannot establish per-node provenance.
-            history = null;
-        }
-        // Only promotions by a VERIFIED (retired) injection qualify. An active
-        // injection's flip is the cascade path's job; a native desired_effect has no
-        // history row at all.
-        const verifiedRows = (history?.history ?? []).filter((h) => h.injection?.injectionStatus === 'verified' &&
-            typeof h.injection?.statement === 'string' &&
-            h.injection.statement.trim() !== '');
-        if (verifiedRows.length > 0) {
-            // PRECISE per-node history path -- wins whenever provenance exists.
-            // The latest verified promotion carries the pre-flip UDE text to restate.
-            const latest = verifiedRows[verifiedRows.length - 1];
-            const originalUde = (latest.previousStatement ?? '').trim();
-            if (originalUde === '')
-                continue;
-            // If the base statement no longer equals the pre-flip UDE text, a restatement
-            // was already promoted into it at verify -> display is already positive -> skip.
-            if (!needsRestatement(node.statement, originalUde))
-                continue;
-            const injectionStatements = [
-                ...new Set(verifiedRows.map((h) => h.injection.statement.trim())),
-            ];
-            candidates.push({ nodeId: node.id, statement: originalUde, injectionStatements });
-            continue;
-        }
-        // PROVENANCE-FREE FALLBACK (opt-in only). No verified-injection history row
-        // exists for this node. If enabled, author conditioned on the tree's
-        // verified/retired injection statements.
-        //
-        // Idempotency for this path is the BLANK-`frtStatement` pre-filter above
-        // (`needsRestatement(n.frtStatement)`): once we write a positive
-        // `frt_statement`, the node is no longer a pre-candidate and a re-run is a
-        // no-op. There is no `previousStatement` snapshot to compare the base text
-        // against (the whole point of this path -- no provenance), so the only base-
-        // text requirement is that the base `statement` is non-blank (there must be
-        // a problem to restate). The base statement is never mutated here.
-        if (!includeFallback)
-            continue;
-        const baseText = (node.statement ?? '').trim();
-        if (baseText === '')
-            continue;
-        const injectionStatements = await treeStatements();
-        // No verified/retired injection anywhere on the tree -> nothing to condition
-        // on -> not a fallback candidate (tree-level no-op).
-        if (injectionStatements.length === 0)
-            continue;
-        candidates.push({
-            nodeId: node.id,
-            statement: baseText,
-            injectionStatements,
-        });
-    }
-    return candidates;
-}
-/**
- * Author missing `frt_statement` prose for the UDEs that verified/retired
- * injections flipped on one tree. Delegates candidate selection to
- * `findRetiredInjectionRestatementCandidates`, then authors one positive
- * future-state sentence per candidate (injection-conditioned) and writes it via
- * `reality_tree_node_update`.
- *
- * Best-effort per node; idempotent (already-authored nodes are not candidates).
- */
-export async function authorRetiredInjectionRestatements(treeId, deps = {}) {
-    const callApi = deps.callApi ?? defaultCallApi;
-    const author = deps.authorRestatement ?? defaultAuthorRestatement;
-    const authored = [];
-    const skipped = [];
-    const candidates = await findRetiredInjectionRestatementCandidates(treeId, {
-        callApi,
-        includeProvenanceFreeFallback: deps.includeProvenanceFreeFallback === true,
-    });
-    for (const candidate of candidates) {
-        try {
-            const text = await author({
-                udeStatement: candidate.statement,
-                injectionStatements: candidate.injectionStatements.length > 0 ? candidate.injectionStatements : undefined,
-            });
-            if (!text || text.trim() === '') {
-                skipped.push(candidate.nodeId);
-                continue;
-            }
-            // DRAFT-ASSIST: mark machine-authored prose as a draft (frt_statement_drafted=true).
-            // The declared desired effect (authored at injection time via the `target`
-            // action) is the source of truth; this loop only backstops the blank case.
-            await callApi('reality_tree_node_update', {
-                nodeId: candidate.nodeId,
-                frtStatement: text.trim(),
-                frtStatementDrafted: true,
-            });
-            authored.push(candidate.nodeId);
-        }
-        catch {
-            // best-effort: skip this node, keep going.
-            skipped.push(candidate.nodeId);
-        }
-    }
-    return { authored, skipped };
-}
-//# sourceMappingURL=retire-aware-restatement.js.map

package/dist/retire-aware-restatement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"retire-aware-restatement.js","sourceRoot":"","sources":["../src/retire-aware-restatement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EACL,iBAAiB,IAAI,wBAAwB,EAC7C,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAgE7B;;;;;;;GAOG;AACH,KAAK,UAAU,qCAAqC,CAClD,MAAc,EACd,OAAkB;IAElB,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;IACrC,KAAK,MAAM,UAAU,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAU,EAAE,CAAC;QACxD,IAAI,IAAsB,CAAC;QAC3B,IAAI,CAAC;YACH,IAAI,GAAG,MAAM,OAAO,CAAmB,wBAAwB,EAAE;gBAC/D,MAAM;gBACN,QAAQ,EAAE,WAAW;gBACrB,MAAM,EAAE,UAAU;aACnB,CAAC,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACP,qEAAqE;YACrE,SAAS;QACX,CAAC;QACD,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,IAAI,EAAE,EAAE,CAAC;YACjC,IACE,CAAC,CAAC,QAAQ,KAAK,WAAW;gBAC1B,CAAC,CAAC,eAAe,KAAK,UAAU;gBAChC,OAAO,CAAC,CAAC,SAAS,KAAK,QAAQ;gBAC/B,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,EACzB,CAAC;gBACD,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,CAAC,GAAG,UAAU,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,yCAAyC,CAC7D,MAAc,EACd,OAAyE,EAAE;IAE3E,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,cAAc,CAAC;IAC/C,MAAM,eAAe,GAAG,IAAI,CAAC,6BAA6B,KAAK,IAAI,CAAC;IAEpE,yEAAyE;IACzE,8EAA8E;IAC9E,MAAM,SAAS,GAAG,MAAM,OAAO,CAAmB,wBAAwB,EAAE;QAC1E,MAAM;QACN,MAAM,EAAE,QAAQ;KACjB,CAAC,CAAC;IACH,MAAM,KAAK,GAAqB,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;IAEtD,+EAA+E;IAC/E,MAAM,aAAa,GAAG,KAAK,CAAC,MAAM,CAChC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,gBAAgB,IAAI,gBAAgB,CAAC,CAAC,CAAC,YAAY,CAAC,CAC3E,CAAC;IAEF,4EAA4E;IAC5E,8EAA8E;IAC9E,IAAI,uBAAuB,GAAoB,IAAI,CAAC;IACpD,MAAM,cAAc,GAAG,KAAK,IAAuB,EAAE;QACnD,IAAI,uBAAuB,KAAK,IAAI,EAAE,CAAC;YACrC,uBAAuB,GAAG,MAAM,qCAAqC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACzF,CAAC;QACD,OAAO,uBAAuB,CAAC;IACjC,CAAC,CAAC;IAEF,MAAM,UAAU,GAAgC,EAAE,CAAC;IAEnD,KAAK,MAAM,IAAI,IAAI,aAAa,EAAE,CAAC;QACjC,IAAI,OAAO,GAAoC,IAAI,CAAC;QACpD,IAAI,CAAC;YACH,OAAO,GAAG,MAAM,OAAO,CAA2B,gCAAgC,EAAE;gBAClF,MAAM,EAAE,IAAI,CAAC,EAAE;aAChB,CAAC,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACP,wEAAwE;YACxE,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;QAED,uEAAuE;QACvE,6EAA6E;QAC7E,sBAAsB;QACtB,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,CAClD,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,SAAS,EAAE,eAAe,KAAK,UAAU;YAC3C,OAAO,CAAC,CAAC,SAAS,EAAE,SAAS,KAAK,QAAQ;YAC1C,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CACtC,CAAC;QAEF,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,oEAAoE;YACpE,0EAA0E;YAC1E,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACrD,MAAM,WAAW,GAAG,CAAC,MAAM,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;YAC5D,IAAI,WAAW,KAAK,EAAE;gBAAE,SAAS;YAEjC,8EAA8E;YAC9E,iFAAiF;YACjF,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC;gBAAE,SAAS;YAE7D,MAAM,mBAAmB,GAAG;gBAC1B,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,CAAC,CAAC,SAAS,CAAC,SAAoB,CAAC,IAAI,EAAE,CAAC,CAAC;aAC9E,CAAC;YAEF,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAC,CAAC;YAClF,SAAS;QACX,CAAC;QAED,4EAA4E;QAC5E,qEAAqE;QACrE,yCAAyC;QACzC,EAAE;QACF,yEAAyE;QACzE,iEAAiE;QACjE,2EAA2E;QAC3E,2EAA2E;QAC3E,6EAA6E;QAC7E,4EAA4E;QAC5E,mEAAmE;QACnE,IAAI,CAAC,eAAe;YAAE,SAAS;QAC/B,MAAM,QAAQ,GAAG,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QAC/C,IAAI,QAAQ,KAAK,EAAE;YAAE,SAAS;QAE9B,MAAM,mBAAmB,GAAG,MAAM,cAAc,EAAE,CAAC;QACnD,6EAA6E;QAC7E,qDAAqD;QACrD,IAAI,mBAAmB,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QAE/C,UAAU,CAAC,IAAI,CAAC;YACd,MAAM,EAAE,IAAI,CAAC,EAAE;YACf,SAAS,EAAE,QAAQ;YACnB,mBAAmB;SACpB,CAAC,CAAC;IACL,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,kCAAkC,CACtD,MAAc,EACd,OAAwB,EAAE;IAE1B,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,cAAc,CAAC;IAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,IAAI,wBAAwB,CAAC;IAElE,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAa,EAAE,CAAC;IAE7B,MAAM,UAAU,GAAG,MAAM,yCAAyC,CAAC,MAAM,EAAE;QACzE,OAAO;QACP,6BAA6B,EAAE,IAAI,CAAC,6BAA6B,KAAK,IAAI;KAC3E,CAAC,CAAC;IAEH,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC;gBACxB,YAAY,EAAE,SAAS,CAAC,SAAS;gBACjC,mBAAmB,EACjB,SAAS,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC,CAAC,SAAS;aACvF,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;gBAChC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;gBAC/B,SAAS;YACX,CAAC;YACD,qFAAqF;YACrF,2EAA2E;YAC3E,2EAA2E;YAC3E,MAAM,OAAO,CAAC,0BAA0B,EAAE;gBACxC,MAAM,EAAE,SAAS,CAAC,MAAM;gBACxB,YAAY,EAAE,IAAI,CAAC,IAAI,EAAE;gBACzB,mBAAmB,EAAE,IAAI;aAC1B,CAAC,CAAC;YACH,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAClC,CAAC;QAAC,MAAM,CAAC;YACP,2CAA2C;YAC3C,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AAC/B,CAAC"}

package/dist/review-defect-detector.d.ts

@@ -1,82 +0,0 @@
-/**
- * Review-defect classification utilities.
- *
- * The state-cascade engine drives review re-engagement off the focus
- * execution phase (verifying / reviewing) -- the older detector that
- * mutated focus.status (in_review/building/verify) was retired with the
- * focus_status enum trim. What remains here is the issue classifier used
- * by focus-executor and the per-focus remediation cycle counter, which
- * may be folded into a future bounded-iteration check.
- *
- * Identifying review-filed issues:
- *   We use `created_by_role_id` (filters out human/UI-filed issues, which
- *   leave the column NULL) AND timing -- the issue was created after the
- *   focus's most recent `review_requested_at`. A single role is often
- *   shared across team and review sessions, so role alone is insufficient;
- *   the timing-plus-role combination is what reliably identifies
- *   "filed during a review pass".
- */
-import type { FocusIssueInfo } from './types.js';
-/**
- * Cap on remediation cycles before escalation. Sourced from the typed
- * env-config (TELORA_REVIEW_REMEDIATION_LIMIT, validated at startup; default 3).
- */
-export declare const REVIEW_REMEDIATION_LIMIT: number;
-export declare function getRemediationCycles(focusId: string): number;
-export declare function incrementRemediationCycles(focusId: string): number;
-export declare function resetRemediationCycles(focusId: string): void;
-/** Test-only: clear all cycle state. */
-export declare function _resetAllRemediationCyclesForTest(): void;
-/**
- * Returns true when an issue was filed during the most recent review pass.
- *
- * An issue is "review-filed" when ALL of:
- *   - It has a non-null created_by_role_id (excludes human/UI creates).
- *   - Its created_at is later than the focus's review_requested_at.
- *   - Its status is open (To Do / In Progress / Blocked).
- */
-export declare function isReviewFiledIssue(issue: Pick<FocusIssueInfo, 'createdByRoleId' | 'createdAt' | 'status'>, reviewRequestedAt: string | null): boolean;
-/**
- * Filter a focus's issues to only those that were filed during the most
- * recent review pass and are still open.
- */
-export declare function filterReviewFiledIssues(issues: FocusIssueInfo[], reviewRequestedAt: string | null): FocusIssueInfo[];
-/**
- * Returns true when there are any review-filed issues (open or closed)
- * since the most recent review pass.
- */
-export declare function reviewFiledIssueExists(issues: FocusIssueInfo[], reviewRequestedAt: string | null): boolean;
-/**
- * Whether a priority label is an explicit, low (deferrable) severity. Null,
- * empty, P0, and P1 are all NOT deferrable.
- */
-export declare function isLowPriority(priority: string | null | undefined): boolean;
-/**
- * Whether an issue is a DEFERRABLE review note: a review-filed, still-open
- * issue (per isReviewFiledIssue) whose priority is an explicit low severity
- * (P2/P3). A deferrable note must NOT route a verify delivery to verify_failed
- * -- the review should converge (approve) and leave the note tracked.
- *
- * Anything that is review-filed but P0/P1 or unprioritized is BLOCKING, and any
- * open work that is NOT review-filed (e.g. pre-existing coding work) is also
- * blocking. Deferrability is a property of low-severity review triage notes
- * only.
- */
-export declare function isDeferrableReviewNote(issue: Pick<FocusIssueInfo, 'createdByRoleId' | 'createdAt' | 'status' | 'priority'>, reviewRequestedAt: string | null): boolean;
-/**
- * Filter a focus's issues to the open, review-filed notes that are deferrable
- * (low severity). The caller uses the ids to mark the matching reconciler
- * issues as `deferrable` so the verify-routing reconciler does not treat them
- * as blocking open work.
- */
-export declare function filterDeferrableReviewNotes(issues: FocusIssueInfo[], reviewRequestedAt: string | null): FocusIssueInfo[];
-/**
- * Returns true when there is at least one BLOCKING review-filed issue since the
- * most recent review pass -- a review-filed, still-open issue that is NOT a
- * deferrable low-severity note (i.e. P0/P1 or unprioritized). This is the gate
- * for the review_missing_report notice: a review that filed ONLY deferrable
- * notes converged cleanly and must not raise the "review skipped its outcome"
- * escalation.
- */
-export declare function blockingReviewFiledIssueExists(issues: FocusIssueInfo[], reviewRequestedAt: string | null): boolean;
-//# sourceMappingURL=review-defect-detector.d.ts.map

package/dist/review-defect-detector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"review-defect-detector.d.ts","sourceRoot":"","sources":["../src/review-defect-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAMjD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,MACU,CAAC;AAYlD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAIlE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED,wCAAwC;AACxC,wBAAgB,iCAAiC,IAAI,IAAI,CAExD;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,iBAAiB,GAAG,WAAW,GAAG,QAAQ,CAAC,EACvE,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,OAAO,CAMT;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,cAAc,EAAE,EACxB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,cAAc,EAAE,CAElB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,cAAc,EAAE,EACxB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,OAAO,CAUT;AAcD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAG1E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,iBAAiB,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC,EACpF,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,cAAc,EAAE,EACxB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,cAAc,EAAE,CAElB;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,cAAc,EAAE,EACxB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,OAAO,CAIT"}

package/dist/review-defect-detector.js

@@ -1,148 +0,0 @@
-/**
- * Review-defect classification utilities.
- *
- * The state-cascade engine drives review re-engagement off the focus
- * execution phase (verifying / reviewing) -- the older detector that
- * mutated focus.status (in_review/building/verify) was retired with the
- * focus_status enum trim. What remains here is the issue classifier used
- * by focus-executor and the per-focus remediation cycle counter, which
- * may be folded into a future bounded-iteration check.
- *
- * Identifying review-filed issues:
- *   We use `created_by_role_id` (filters out human/UI-filed issues, which
- *   leave the column NULL) AND timing -- the issue was created after the
- *   focus's most recent `review_requested_at`. A single role is often
- *   shared across team and review sessions, so role alone is insufficient;
- *   the timing-plus-role combination is what reliably identifies
- *   "filed during a review pass".
- */
-import { OPEN_ISSUE_STATUSES } from './constants.js';
-import { loadEnvConfig } from '@telora/daemon-core';
-// ── Configuration ────────────────────────────────────────────────────────
-/**
- * Cap on remediation cycles before escalation. Sourced from the typed
- * env-config (TELORA_REVIEW_REMEDIATION_LIMIT, validated at startup; default 3).
- */
-export const REVIEW_REMEDIATION_LIMIT = loadEnvConfig().TELORA_REVIEW_REMEDIATION_LIMIT;
-// ── Per-focus cycle counter ──────────────────────────────────────────
-/**
- * In-memory map of focus ID -> consecutive remediation cycles. Cycle
- * counts are not persisted -- a daemon restart resets the counter, which
- * is acceptable because the bound exists to prevent runaway loops within
- * a single daemon lifetime, not across restarts.
- */
-const remediationCycles = new Map();
-export function getRemediationCycles(focusId) {
-    return remediationCycles.get(focusId) ?? 0;
-}
-export function incrementRemediationCycles(focusId) {
-    const next = (remediationCycles.get(focusId) ?? 0) + 1;
-    remediationCycles.set(focusId, next);
-    return next;
-}
-export function resetRemediationCycles(focusId) {
-    remediationCycles.delete(focusId);
-}
-/** Test-only: clear all cycle state. */
-export function _resetAllRemediationCyclesForTest() {
-    remediationCycles.clear();
-}
-// ── Issue classification ────────────────────────────────────────────────
-/**
- * Returns true when an issue was filed during the most recent review pass.
- *
- * An issue is "review-filed" when ALL of:
- *   - It has a non-null created_by_role_id (excludes human/UI creates).
- *   - Its created_at is later than the focus's review_requested_at.
- *   - Its status is open (To Do / In Progress / Blocked).
- */
-export function isReviewFiledIssue(issue, reviewRequestedAt) {
-    if (!issue.createdByRoleId)
-        return false;
-    if (!OPEN_ISSUE_STATUSES.has(issue.status))
-        return false;
-    if (!reviewRequestedAt)
-        return false;
-    if (!issue.createdAt)
-        return false;
-    return new Date(issue.createdAt).getTime() >= new Date(reviewRequestedAt).getTime();
-}
-/**
- * Filter a focus's issues to only those that were filed during the most
- * recent review pass and are still open.
- */
-export function filterReviewFiledIssues(issues, reviewRequestedAt) {
-    return issues.filter(i => isReviewFiledIssue(i, reviewRequestedAt));
-}
-/**
- * Returns true when there are any review-filed issues (open or closed)
- * since the most recent review pass.
- */
-export function reviewFiledIssueExists(issues, reviewRequestedAt) {
-    if (!reviewRequestedAt)
-        return false;
-    for (const i of issues) {
-        if (!i.createdByRoleId)
-            continue;
-        if (!i.createdAt)
-            continue;
-        if (new Date(i.createdAt).getTime() >= new Date(reviewRequestedAt).getTime()) {
-            return true;
-        }
-    }
-    return false;
-}
-// ── Deferrability classification ──────────────────────────────────────────
-/**
- * Priority labels that mark a review-filed note as DEFERRABLE (low severity,
- * acceptable to defer past the verify gate). The blocking set is everything
- * else -- P0/P1 AND a null/unset priority. The asymmetry is deliberate: the
- * control loop moves reality toward intent and never lowers the bar, so an
- * unprioritized note is treated as BLOCKING (route to verify_failed), not
- * silently converged. Only an EXPLICIT low priority makes a note deferrable.
- */
-const DEFERRABLE_PRIORITIES = new Set(['P2', 'P3']);
-/**
- * Whether a priority label is an explicit, low (deferrable) severity. Null,
- * empty, P0, and P1 are all NOT deferrable.
- */
-export function isLowPriority(priority) {
-    if (!priority)
-        return false;
-    return DEFERRABLE_PRIORITIES.has(priority.trim().toUpperCase());
-}
-/**
- * Whether an issue is a DEFERRABLE review note: a review-filed, still-open
- * issue (per isReviewFiledIssue) whose priority is an explicit low severity
- * (P2/P3). A deferrable note must NOT route a verify delivery to verify_failed
- * -- the review should converge (approve) and leave the note tracked.
- *
- * Anything that is review-filed but P0/P1 or unprioritized is BLOCKING, and any
- * open work that is NOT review-filed (e.g. pre-existing coding work) is also
- * blocking. Deferrability is a property of low-severity review triage notes
- * only.
- */
-export function isDeferrableReviewNote(issue, reviewRequestedAt) {
-    return isReviewFiledIssue(issue, reviewRequestedAt) && isLowPriority(issue.priority);
-}
-/**
- * Filter a focus's issues to the open, review-filed notes that are deferrable
- * (low severity). The caller uses the ids to mark the matching reconciler
- * issues as `deferrable` so the verify-routing reconciler does not treat them
- * as blocking open work.
- */
-export function filterDeferrableReviewNotes(issues, reviewRequestedAt) {
-    return issues.filter(i => isDeferrableReviewNote(i, reviewRequestedAt));
-}
-/**
- * Returns true when there is at least one BLOCKING review-filed issue since the
- * most recent review pass -- a review-filed, still-open issue that is NOT a
- * deferrable low-severity note (i.e. P0/P1 or unprioritized). This is the gate
- * for the review_missing_report notice: a review that filed ONLY deferrable
- * notes converged cleanly and must not raise the "review skipped its outcome"
- * escalation.
- */
-export function blockingReviewFiledIssueExists(issues, reviewRequestedAt) {
-    return issues.some(i => isReviewFiledIssue(i, reviewRequestedAt) && !isLowPriority(i.priority));
-}
-//# sourceMappingURL=review-defect-detector.js.map