looply-cli 0.0.0-stage → 0.2.0

package/dist/goal-adaptive.d.ts.map

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

package/dist/goal-adaptive.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADAPTIVE_MAX_STEPS = exports.MAX_PLAN_REVISIONS_PER_GOAL_VERSION = void 0;
+exports.decideAdaptive = decideAdaptive;
+exports.gapText = gapText;
+exports.describeAdaptive = describeAdaptive;
+const core_1 = require("@looply/core");
+/**
+ * WHETHER TO TRY AGAIN, ONCE.
+ *
+ * The decision a Start makes when the plan it was given is exhausted and
+ * nothing else can move: is the goal actually met, is something still missing
+ * and worth one more bounded plan, or is this a question for a person?
+ *
+ * ONE START, AT MOST ONE RUN. This decides BEFORE the run — it may produce one
+ * more plan for the run to work — and it is never consulted again afterwards.
+ * Nothing here loops: it evaluates once, compiles at most once, and returns.
+ * The next adaptive decision needs another explicit Start.
+ *
+ * It composes rather than reasons. The evaluator says what is missing, the
+ * compiler turns that into work, and this file decides whether either is
+ * allowed to happen — which is why it takes both as callbacks and reaches for
+ * no model itself.
+ */
+/**
+ * How many plans one goal version may have.
+ *
+ * The first, and two more. The shape of the argument is the same as an item's
+ * three attempts: a second try informed by what the first one left undone is
+ * worth having, a third is the last one that can plausibly be better informed,
+ * and past that a system that cannot say why it is failing should stop rather
+ * than keep spending. It survives restarts and redeliveries because it is read
+ * off the queue, and a new Start does not reset it.
+ *
+ * Separate from MAX_ITEM_EXECUTION_ATTEMPTS on purpose. One bounds how often a
+ * piece of work may be retried; this bounds how often the plan itself may be
+ * rethought. Spending one on the other would let three failed items exhaust a
+ * goal's ability to try a different approach.
+ */
+exports.MAX_PLAN_REVISIONS_PER_GOAL_VERSION = 3;
+/**
+ * How many steps an adaptive plan may contain.
+ *
+ * Smaller than the initial plan's six, and the arithmetic is the reason: an
+ * adaptive Start pays for an evaluation AND a compilation AND a verify pass
+ * before `run.started` acks it, against a sixty-minute window. Four keeps that
+ * sum at 38 minutes with a third of the window spare, which is the margin the
+ * compiler's own bound already keeps. It is also honest about the job — filling
+ * named gaps is a smaller task than planning a goal from nothing.
+ */
+exports.ADAPTIVE_MAX_STEPS = 4;
+/**
+ * Decide, once.
+ *
+ * The order is the argument. Every check that could stop the decision comes
+ * before the one thing that costs money and the one thing that spends a
+ * revision, and the two authority checks bracket the evaluation rather than
+ * merely preceding it.
+ */
+async function decideAdaptive(input, deps) {
+    const before = await deps.changedPaths();
+    if (before.length) {
+        /**
+         * Someone else's uncommitted work. Not ours to reason about, and running an
+         * agent over it would make whatever it did indistinguishable from theirs.
+         *
+         * NOT `stale`, which `describeAdaptive` renders as "this goal moved while
+         * it was being checked". The goal did not move; a tree has work in it, the
+         * person can commit or stash it, and the next Start will get past this. So
+         * it is retryable and it says what is actually true.
+         */
+        return {
+            kind: 'no-decision',
+            reason: `the working tree has ${before.length} uncommitted change(s) — commit or stash them first`,
+        };
+    }
+    const headBefore = await deps.headSha();
+    const outcome = await deps.evaluate({
+        goalId: input.goalId,
+        goalVersion: input.goalVersion,
+        goalText: input.goalText,
+        planRevision: input.currentRevision,
+        projectName: input.projectName,
+        planItems: input.planItems.map((i) => ({ title: i.title, state: i.state, attempts: i.attempts })),
+        headSha: headBefore,
+        // F37: what the programme's other goals own is never this goal's gap (see `GoalGapInput.ownedElsewhere`).
+        ...(input.packet?.ownedElsewhere === undefined || input.packet.ownedElsewhere.length === 0
+            ? {}
+            : { ownedElsewhere: input.packet.ownedElsewhere }),
+    });
+    /**
+     * The containment check, before the answer is read. An evaluator that changed
+     * the repository has already broken the terms it was asked under, and what it
+     * said is not worth reading whatever it said.
+     *
+     * TWO questions, because one of them cannot see the other. `changedPaths` is
+     * the working tree against HEAD, so a COMMIT leaves it empty — and the
+     * evaluator runs as `claude -p --dangerously-skip-permissions` in a shell
+     * that inherits the repository as its cwd, with a configured git identity.
+     * It can commit, and this was measured rather than assumed.
+     *
+     * The HEAD comparison used to guard only the `satisfied` branch, where it is
+     * a precondition of KEY 2. Containment is a different question and applies to
+     * every verdict: an `incomplete` answer from an evaluator that rewrote the
+     * repository is not a plan to act on either.
+     */
+    const after = await deps.changedPaths();
+    if (after.length)
+        return { kind: 'mutated', paths: after };
+    const headAfter = await deps.headSha();
+    if (headAfter !== headBefore) {
+        /**
+         * HONEST ABOUT WHAT IS AND IS NOT KNOWN.
+         *
+         * A commit landed during a task that was asked to read. The evaluator CAN
+         * be the one that made it — measured, not assumed: it runs as
+         * `claude -p --dangerously-skip-permissions` in a shell inheriting the
+         * repository, with a git identity. But a person or another process could
+         * equally have committed in that window, and nothing here can tell which.
+         *
+         * So the answer is void either way, and the message says what happened
+         * rather than naming a culprit. TERMINAL rather than retryable: retrying
+         * would re-offer the command every three seconds for an hour, each attempt
+         * spending a fresh eight-minute evaluation, and if the evaluator IS the
+         * committer every one of them would do it again. A person, or a controller
+         * with budget left, can deliberately ask again.
+         */
+        return { kind: 'mutated', paths: [], movedHeadTo: headAfter };
+    }
+    // Retryable, and deliberately BEFORE any revision is considered: a timeout or
+    // an unreadable answer must never spend one of three plans.
+    if (!outcome.ok)
+        return { kind: 'no-decision', reason: outcome.reason };
+    const verdict = outcome.verdict;
+    /**
+     * Authority, before ANY terminal answer.
+     *
+     * It was added to `satisfied` alone, on the reasoning that a path which says
+     * something terminal must not say it about wording a person has replaced.
+     * That reasoning does not single `satisfied` out: `human-required` and
+     * `budget-exhausted` are equally terminal, equally told to a person, and
+     * equally about a goal that may have moved during the minutes the evaluation
+     * took. Asking once here covers all three rather than three times below.
+     */
+    const authoritative = await deps.stillAuthoritative();
+    if (!authoritative.ok) {
+        return authoritative.unknown === true
+            ? { kind: 'no-decision', reason: authoritative.reason }
+            : { kind: 'stale', reason: authoritative.reason, lapse: authoritative.lapse };
+    }
+    if (verdict.kind === 'human-required')
+        return { kind: 'human-required', reason: verdict.reason };
+    if (verdict.kind === 'satisfied') {
+        // KEY 2. The evaluator is necessary and never sufficient — it is the same
+        // write-capable machinery that produced the work it is judging.
+        /**
+         * HEAD is `headBefore` here by construction: the containment check above
+         * refuses any evaluation during which HEAD moved, whoever moved it. So the
+         * head KEY 2 is asked about is the head the answer was read at, which is
+         * the precondition `confirmSatisfied` needs and used to enforce for itself.
+         *
+         * Kept as an argument rather than re-read, so the two cannot drift.
+         */
+        const confirmed = await deps.confirmSatisfied(headBefore);
+        if (!confirmed.ok) {
+            // `unknown` is "I could not find out", which is retryable. Everything
+            // else is a fact about the work, which is terminal.
+            return confirmed.unknown === true
+                ? { kind: 'no-decision', reason: confirmed.reason }
+                : { kind: 'unconfirmed', reason: confirmed.reason };
+        }
+        return verdict.summary === undefined
+            ? { kind: 'satisfied' }
+            : { kind: 'satisfied', summary: verdict.summary };
+    }
+    // Incomplete. One more plan, if there is one left.
+    if (input.currentRevision >= exports.MAX_PLAN_REVISIONS_PER_GOAL_VERSION) {
+        return { kind: 'budget-exhausted', revision: input.currentRevision, gaps: verdict.gaps };
+    }
+    // Authority is re-checked HERE, after the evaluation and before anything
+    // durable is written. The evaluation may have taken minutes, and a goal that
+    // has been amended or given up in that time must not receive work planned
+    // under the wording it had before.
+    const still = await deps.stillAuthoritative();
+    if (!still.ok) {
+        return still.unknown === true
+            ? { kind: 'no-decision', reason: still.reason }
+            : { kind: 'stale', reason: still.reason, lapse: still.lapse };
+    }
+    const revision = input.currentRevision + 1;
+    const steps = await deps.compile({
+        goalId: input.goalId,
+        goalVersion: input.goalVersion,
+        goalText: gapText(input.goalText, verdict.gaps),
+        projectId: input.projectId,
+        projectName: input.projectName,
+        ...(input.packet === undefined ? {} : { packet: input.packet }),
+        ...(input.checks === undefined ? {} : { checks: input.checks }),
+    }, exports.ADAPTIVE_MAX_STEPS);
+    // A compilation that failed spends nothing: no rows are written, so the
+    // revision was never materialised and the next Start tries the same one.
+    if (!steps.ok)
+        return { kind: 'no-decision', reason: steps.reason };
+    if (!steps.steps.length && steps.malformed > 0) {
+        // UNREADABLE, not empty — and the same distinction the initial compile
+        // makes. `extractPlan` drops steps it cannot parse and carries on, so a
+        // transcript of malformed objects arrives as `ok: true` with none. Spending
+        // one of three revisions on an answer nobody could read would durably
+        // record a plan that never existed. The first fix for this was applied only
+        // to revision 1; this is its twin.
+        return {
+            kind: 'no-decision',
+            reason: `the plan could not be read — ${steps.malformed} step(s) were malformed`,
+        };
+    }
+    /**
+     * ASKED AGAIN, immediately before the caller makes anything durable.
+     *
+     * The check above happens before a compilation that may take ten minutes, so
+     * on its own it is an authority check separated from the write it guards by
+     * most of the command window. A person who amends or abandons the goal during
+     * the compile would have work materialised under wording nobody wants, and
+     * the earlier check would have passed honestly.
+     *
+     * Cheap — a local file read — and it is the LAST thing between deciding and
+     * writing. Two checks bracketing the evaluation and one more bracketing the
+     * compilation is the whole of the authority story.
+     */
+    const stillNow = await deps.stillAuthoritative();
+    if (!stillNow.ok) {
+        return stillNow.unknown === true
+            ? { kind: 'no-decision', reason: stillNow.reason }
+            : { kind: 'stale', reason: stillNow.reason, lapse: stillNow.lapse };
+    }
+    return { kind: 'planned', revision, steps, gaps: verdict.gaps };
+}
+/**
+ * What the compiler is asked for, once a gap is known.
+ *
+ * The goal's own wording stays first and whole — it is what the work is for —
+ * and the gaps are added as what is left of it. The compiler is not told how to
+ * close them; naming the remedy is the evaluator overstepping, and this is the
+ * seam where that would happen if it were going to.
+ */
+function gapText(goalText, gaps) {
+    const lines = gaps.map((g) => `  - ${g.description}`).join('\n');
+    return `${goalText}\n\nWork has already been done for this. What is still missing:\n${lines}`;
+}
+function describeAdaptive(decision, 
+/**
+ * What a person has attested about the requirements this goal names.
+ *
+ * 🔴 THE SENTENCE A PERSON READS AT THE MOMENT OF THE CLAIM SAID NOTHING
+ * ABOUT COVERAGE. "This goal looks done" rests on two keys — the evaluator's
+ * verdict and the machine's own evidence — and neither asks whether the
+ * requirements the goal named have been attested by anybody. The audit's
+ * C-08, and the only row in M8-1's census that can make a COMPLETED claim
+ * wrong.
+ *
+ * ⚠️ IT CHANGES NO DECISION. `satisfied` is still reached by exactly the two
+ * keys it was reached by before; this adds a clause to what that outcome
+ * SAYS, never a condition on when it is returned. Blocking completion on
+ * coverage would mean no goal naming requirements could complete
+ * autonomously without a person attesting first, which is a decision about
+ * autonomy and belongs to the owner.
+ *
+ * Absent or null — including for every goal that names no requirements —
+ * leaves the message byte-identical to what it was.
+ */
+attested, 
+/**
+ * D3 — the fourth key, when the caller could compute it.
+ *
+ * 🔴 THIS IS THE CONDITION THE DOCBLOCK ABOVE SAYS IT DOES NOT ADD, and it is
+ * added now because the owner decided it (charter §5 decision 3). The comment
+ * above is amended rather than deleted: it was right that this is an autonomy
+ * decision and right that it was not a cycle's to make.
+ *
+ * ⚠️ UNDEFINED MEANS THE CALLER COULD NOT ASK, NOT THAT COVERAGE IS FINE. A
+ * caller with no server, no measurement or no classifications passes nothing
+ * and the ending is byte-identical to what it was — which keeps Simple Mode
+ * and every goal naming no requirements exactly as they were. It does NOT
+ * silently grant coverage: a caller that wants the fourth key enforced must
+ * compute it, and `run-cmd` does.
+ */
+coverage) {
+    switch (decision.kind) {
+        case 'planned':
+            return null;
+        case 'satisfied': {
+            const uncovered = (0, core_1.describeAttested)(attested ?? null);
+            /**
+             * 🔴 THE FOURTH KEY, BEFORE THE CLAIM IS MADE.
+             *
+             * Two keys decided the work was delivered; this asks whether what the
+             * goal NAMED is covered. `workLeft` "knows nothing about goals", so
+             * without this "the goal is met" has meant "every item in this slice is
+             * out of the way" — a plan the machine wrote, judged done by the machine
+             * that wrote it.
+             *
+             * The refusal carries the facts and takes no decision: `coverageGate`
+             * already distinguishes unmeasured, absent, conflicting, blocked, stale,
+             * partial and unreceipted, because each one sends a person somewhere
+             * different.
+             */
+            const blocked = coverage === undefined ? null : (0, core_1.describeCoverageBlock)(coverage);
+            if (blocked !== null) {
+                return {
+                    terminal: true,
+                    code: 'coverage_incomplete',
+                    message: `this goal's work looks delivered, but it is not complete -- ${blocked}` +
+                        (decision.summary === undefined ? '' : ` (${decision.summary})`),
+                };
+            }
+            return {
+                terminal: true,
+                code: 'goal_satisfied',
+                message: `this goal looks done${decision.summary === undefined ? '' : ` -- ${decision.summary}`}` +
+                    (uncovered === null ? '' : ` -- but ${uncovered}`),
+            };
+        }
+        case 'budget-exhausted':
+            return {
+                terminal: true,
+                code: 'adaptive_budget_exhausted',
+                message: `this goal has had ${decision.revision} plans and is still not done -- ` +
+                    'it needs you now, not another plan',
+            };
+        case 'human-required':
+            return {
+                terminal: true,
+                code: 'human_required',
+                message: `this goal needs you to decide something -- ${decision.reason}`,
+            };
+        case 'mutated':
+            return {
+                terminal: true,
+                // Its own code, not a generic refusal: a controller must never answer
+                // this with another Start. If the evaluator is what changed the
+                // repository, every retry makes it do the same thing again.
+                code: 'evaluator_repository_changed',
+                message: decision.movedHeadTo === undefined
+                    ? `the goal check changed ${decision.paths.length} file(s) instead of just reading -- ` +
+                        'refusing to act on what it said'
+                    : 'the repository was committed to while the goal was being checked, so the ' +
+                        'answer is about a tree that no longer exists -- refusing to act on it',
+            };
+        case 'stale':
+            return {
+                terminal: true,
+                // `stale` covers both "amended" and "given up". The reason distinguishes
+                // them for a person; a controller stops either way, and stops for a
+                // reason it can name.
+                code: decision.lapse === 'abandoned' ? 'goal_abandoned' : 'goal_superseded',
+                message: `this goal moved while it was being checked -- ${decision.reason}`,
+            };
+        case 'unconfirmed':
+            /**
+             * TERMINAL, and it was retryable until the completion key changed.
+             *
+             * When KEY 2 was evidence-cache freshness, a refusal plausibly meant a
+             * verification was missing or recorded against an older commit — a
+             * bookkeeping gap that the next Start might well find filled, so
+             * retrying was right and making it terminal would have let bookkeeping
+             * end a goal.
+             *
+             * It now means something else entirely: no round for this revision
+             * committed, or the gate did not pass every required step, or the
+             * repository has moved past the commit that was checked. None of those
+             * change on their own. Retrying buys a start-run re-offered every three
+             * seconds for an hour, each attempt spending a fresh eight-minute
+             * evaluation to reach the same answer, and telling the person nothing.
+             */
+            return {
+                terminal: true,
+                // NOT `goal_satisfied`. The evaluator said met; the machine could not
+                // confirm it. These two sentences share their first five words, which
+                // is exactly why the code exists.
+                code: 'run_refused',
+                message: `this goal looks done, but nothing here proves it — ${decision.reason}`,
+            };
+        case 'no-decision':
+            // Retryable, so the code is the generic terminal one and is never read:
+            // `terminal: false` is what the caller branches on.
+            return { terminal: false, code: 'run_refused', message: `could not check this goal -- ${decision.reason}` };
+        default: {
+            // Exhaustiveness, enforced by the compiler rather than by remembering.
+            const unhandled = decision;
+            return unhandled;
+        }
+    }
+}
+//# sourceMappingURL=goal-adaptive.js.map

package/dist/goal-adaptive.js.map

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