@tacuchi/agent-workflow-cli 20.26.0 → 21.1.0

package/dist/application/flow/run-projection.js

@@ -0,0 +1,80 @@
+/**
+ * What a stopped run looks like from OUTSIDE the conversation that stopped it.
+ *
+ * `resume` and `status` both answer "what is left and how does it continue", and
+ * a run standing at a boundary is the most precise answer either of them can
+ * give. They read it from HERE, once: two surfaces deriving "what is next" on
+ * their own would be the second authority this whole initiative exists to remove
+ * — and the one that matters most, because it is the one a person acts on.
+ *
+ * Read-only and fail-quiet by design: a session with no run is a legacy session
+ * (`null`, and the caller keeps its own answer), and a run whose state does not
+ * match its journey says so instead of projecting a boundary nobody can trust.
+ */
+import { journeyOfFlow } from "../../domain/flow/authority.js";
+import { checkAgainstJourney } from "../../domain/flow/run-state.js";
+import { resolveBoundary } from "./advance.js";
+import { locateRun, readRun } from "./run-state-service.js";
+export async function projectRun(fs, paths, folder) {
+    const read = await readRun(fs, locateRun(paths, folder));
+    if (!read.ok) {
+        // An absent run is the normal case for every session older than the engine;
+        // a refusal is not, and hiding it would let `resume` propose work over a state
+        // the engine will not touch.
+        if (read.failure.code === "FLOW_RUN_ABSENT")
+            return null;
+        return {
+            flow: "?",
+            boundary: "blocked",
+            transition: null,
+            title: null,
+            invocation: null,
+            command: `aw flow advance --session ${folder} --adopt`,
+            summary: `corrida ilegible (${read.failure.code}): ${read.failure.action}`,
+        };
+    }
+    const journey = journeyOfFlow(read.state.flow);
+    const incoherent = checkAgainstJourney(read.state, journey);
+    if (incoherent !== null) {
+        return {
+            flow: read.state.flow,
+            boundary: "blocked",
+            transition: read.state.boundary,
+            title: null,
+            invocation: null,
+            command: `aw flow advance --session ${folder}`,
+            summary: `${incoherent.message} — ${incoherent.action}`,
+        };
+    }
+    const resolved = resolveBoundary(read.state, journey);
+    const stopped = resolved.stopped;
+    if (stopped === null) {
+        return {
+            flow: read.state.flow,
+            boundary: "final",
+            transition: null,
+            title: null,
+            invocation: null,
+            command: `aw session-close --code ${folder}`,
+            summary: "el recorrido no tiene transiciones pendientes",
+        };
+    }
+    const invocation = resolved.action === null
+        ? null
+        : [resolved.action.invocation.program, ...resolved.action.invocation.args].join(" ");
+    return {
+        flow: read.state.flow,
+        boundary: resolved.kind,
+        transition: stopped.id,
+        title: stopped.title,
+        invocation,
+        // At an execution boundary what continues the run is the invocation itself —
+        // anything else would send whoever resumes to re-derive the command from
+        // prose, which is exactly what the sealed action exists to prevent.
+        command: invocation ?? `aw flow advance --session ${folder}`,
+        summary: invocation === null
+            ? `frontera ${resolved.kind} en ${stopped.id} — ${stopped.title}`
+            : `frontera execution en ${stopped.id} — ejecutá '${invocation}' y devolvé su salida real con 'aw flow submit --session ${folder}'`,
+    };
+}
+//# sourceMappingURL=run-projection.js.map

package/dist/application/flow/run-projection.js.map

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

package/dist/application/flow/run-state-service.js

@@ -0,0 +1,107 @@
+/**
+ * Reading and writing the run state — the only place that touches the file.
+ *
+ * Two properties matter here and nothing else does:
+ *
+ * - **Serialized.** Every application takes the run's own lock (the
+ *   `lock-service` that already exists — exclusive create, TTL, pid), re-reads
+ *   the state INSIDE it and only then computes the next one. Two processes
+ *   racing on one run cannot produce last-writer-wins: the second is told the
+ *   lock is held and gets an action, it never overwrites applied transitions.
+ * - **All-or-nothing.** The next state is fully built, validated and sealed
+ *   before the single write happens, so a failure halfway through leaves the
+ *   previous state exactly as it was rather than a half-applied one.
+ */
+import { join } from "node:path";
+import { FLOW_RUN_STATE_FILE, parseRunState, serializeRunState, } from "../../domain/flow/run-state.js";
+import { LockBusyError, acquireLock } from "../lock-service.js";
+export function locateRun(paths, session) {
+    const dir = join(paths.cwdSessionsDir(), session);
+    return {
+        session,
+        dir,
+        statePath: join(dir, FLOW_RUN_STATE_FILE),
+        lockPath: join(dir, `${FLOW_RUN_STATE_FILE}.lock`),
+    };
+}
+/**
+ * Read the run state.
+ *
+ * `FLOW_RUN_ABSENT` is a first-class answer, not an error to swallow: a session
+ * opened before the engine existed has no state, and treating that as corruption
+ * would send a legacy run to a repair action it does not need. Its action is
+ * adoption.
+ */
+export async function readRun(fs, location) {
+    if (!(await fs.exists(location.statePath))) {
+        return {
+            ok: false,
+            failure: {
+                code: "FLOW_RUN_ABSENT",
+                message: `la sesión '${location.session}' no tiene estado de corrida`,
+                action: "es una sesión legacy: adoptala con 'aw flow advance --session <código> --flow <flow> --adopt'",
+            },
+        };
+    }
+    return parseRunState(await fs.readText(location.statePath));
+}
+/**
+ * Run one mutation under the run's lock and persist its result.
+ *
+ * The mutation receives the state as it is INSIDE the lock — never the copy the
+ * caller had — which is what makes this a compare-and-swap instead of a hopeful
+ * overwrite.
+ */
+export async function applyUnderLock(fs, location, mutate, options = {}) {
+    const { expectDigest, allowAbsent, ...lockOptions } = options;
+    await fs.mkdirp(location.dir);
+    let lock;
+    try {
+        lock = await acquireLock(location.lockPath, fs, lockOptions);
+    }
+    catch (err) {
+        if (err instanceof LockBusyError) {
+            return {
+                ok: false,
+                failure: {
+                    code: "FLOW_RUN_LOCKED",
+                    message: `otra invocación tiene la corrida tomada (pid ${err.holder.pid} desde ${err.holder.ts})`,
+                    action: "esperá a que termine y volvé a correr 'aw flow advance': no se pisan transiciones aplicadas",
+                },
+            };
+        }
+        throw err;
+    }
+    try {
+        const current = await readRun(fs, location);
+        if (!current.ok) {
+            const absent = current.failure.code === "FLOW_RUN_ABSENT";
+            if (!absent || allowAbsent !== true)
+                return { ok: false, failure: current.failure };
+        }
+        const state = current.ok ? current.state : null;
+        if (expectDigest !== undefined && state?.digest !== expectDigest) {
+            return {
+                ok: false,
+                failure: {
+                    code: "FLOW_RUN_STALE",
+                    message: "el estado de la corrida cambió después de emitirse la directiva",
+                    action: "volvé a correr 'aw flow advance' y respondé sobre la frontera recalculada",
+                },
+            };
+        }
+        const result = await mutate(state);
+        if (!result.ok)
+            return result;
+        if (result.persist === false)
+            return result;
+        // One write, after the next state is complete and sealed: nothing partial
+        // can be observed because nothing partial is ever written.
+        await fs.writeText(location.statePath, serializeRunState(result.state));
+        return result;
+    }
+    finally {
+        await lock.release();
+    }
+}
+//# sourceMappingURL=run-state-service.js.map

package/dist/application/flow/run-state-service.js.map

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

package/dist/application/flow/submit.js

@@ -0,0 +1,423 @@
+/**
+ * An answer comes back, and either it survives validation or nothing moves.
+ *
+ * The order of the checks is the contract, not an implementation detail:
+ *
+ * 1. **Resend first.** The attempt history is hydrated from the persisted state
+ *    and consulted before anything else. A resend of an answer that was already
+ *    applied quotes the seal of a boundary the run has since left, so judging
+ *    staleness first would report "stale" for what is really "already applied" —
+ *    and would tempt the sender into answering twice.
+ * 2. **Then the boundary in force.** Which shape is admissible comes from the
+ *    boundary, never from a flag: the same `submit` answers a semantic boundary,
+ *    a human one and an authorization one.
+ * 3. **Then apply.** Only a surviving answer becomes a transition, and only then
+ *    does the run keep advancing until the next boundary. One surviving answer
+ *    deliberately applies nothing: an approval over a step doctrine still owns
+ *    grants the effect and leaves the run where it stands.
+ *
+ * Every rejection travels with `ok: true` inside the RECALCULATED directive,
+ * carrying its code, message and action — with `ok: false` the host never calls
+ * `renderHuman`, and a boundary nobody can see is a boundary that did not happen.
+ */
+import { AttemptLedger } from "../../domain/capability/protocol.js";
+import { claimedSeal, parseFlowAnswer } from "../../domain/flow/answer.js";
+import { actionOf, effectsOf, journeyOfFlow, } from "../../domain/flow/authority.js";
+import { effectApprovalDigest } from "../../domain/flow/authorization.js";
+import { PAUSE_LABEL, STOP_LABEL, stepOf, } from "../../domain/flow/directive.js";
+import { applyTransition, checkAgainstJourney, withApproval, withAttempt, withBoundary, withObservation, } from "../../domain/flow/run-state.js";
+import { semanticDigest } from "../semantic-operation/protocol.js";
+import { resolveSessionTarget } from "../session-resolver.js";
+import { actionDigest, advanceFlowRun, directiveFor, resolveBoundary, } from "./advance.js";
+import { applyUnderLock, locateRun } from "./run-state-service.js";
+export async function submitFlow(fs, paths, input) {
+    const resolution = await resolveSessionTarget(fs, paths, {
+        ...(input.code !== undefined ? { code: input.code } : {}),
+        ...(input.contextId !== undefined ? { contextId: input.contextId } : {}),
+        allowClosed: false,
+        bind: true,
+    });
+    if (resolution.outcome !== "resolved")
+        return { ok: false, session: resolution };
+    const location = locateRun(paths, resolution.session.folder);
+    const applied = await applyUnderLock(fs, location, (current) => {
+        if (current === null) {
+            return {
+                ok: false,
+                failure: {
+                    code: "FLOW_RUN_ABSENT",
+                    message: "no hay corrida que responder en esta sesión",
+                    action: "adoptala primero con 'aw flow advance --flow <flow> --adopt'",
+                },
+            };
+        }
+        return decide(current, input);
+    });
+    if (!applied.ok)
+        return { ok: false, failure: applied.failure };
+    return { ok: true, directive: applied.value };
+}
+function decide(state, input) {
+    const journey = journeyOfFlow(state.flow);
+    const incoherent = checkAgainstJourney(state, journey);
+    if (incoherent !== null)
+        return { ok: false, failure: incoherent };
+    const resolved = resolveBoundary(state, journey);
+    if (resolved.stopped === null) {
+        return reject(state, resolved, "el recorrido ya terminó: no hay frontera que responder", {
+            code: "FLOW_ANSWER_NOT_EXPECTED",
+            action: "no queda trabajo pendiente en este recorrido",
+        });
+    }
+    if (state.boundary === null) {
+        return reject(state, resolved, "esta corrida todavía no se detuvo en ninguna frontera", {
+            code: "FLOW_ANSWER_NOT_EXPECTED",
+            action: "corré 'aw flow advance' primero: la frontera la emite el motor, no el llamador",
+        });
+    }
+    // The seal the payload CLAIMS keys the lookup, not the current one: a resend of
+    // an answer that was already applied quotes a boundary the run has left, and
+    // looking it up under today's seal would never find it. A forged seal buys
+    // nothing — matching a recorded attempt requires resending exactly what already
+    // ran, and a retry applies nothing.
+    const identity = attemptIdentity(state, input, claimedSeal(input.raw) ?? resolved.seal, resolved.stopped.id);
+    // 1 · Resend, before anything else.
+    const resend = resendCheck(state, resolved, identity);
+    if (resend !== null)
+        return resend;
+    // The action the run is waiting on is the one that was EMITTED, and the seal
+    // would already refuse a result about any other. What the persisted digest adds
+    // is the diagnosis: when the two differ, the invocation changed underneath a run
+    // in flight (a CLI upgraded mid-run), which is a different problem from a state
+    // that moved — and it has a different answer.
+    const drifted = actionDrift(state, resolved);
+    if (drifted !== null)
+        return drifted;
+    // 2 · The boundary in force decides what is admissible.
+    const admissible = admit(state, resolved, resolved.stopped, input, { journey, identity });
+    if ("decision" in admissible)
+        return admissible.decision;
+    const parsed = admissible;
+    // 3 · Apply: the answer is the INPUT to the CLI's decision, so what advances is
+    // the transition, never the sender's own verdict.
+    const granted = resolved.kind === "authorization" ? (resolved.authorization?.planned ?? []) : [];
+    const approved = granted.length > 0 ? withApproval(state, granted) : state;
+    // An approval NEVER applies a step by itself. Two reasons it must hold, and the
+    // second is the one this phase exists for: doctrine may still own the rule, or
+    // the step may be delegated — and an approval that applied a delegated
+    // transition would record the search, the write or the check as done because
+    // someone said the effect was allowed.
+    const holds = resolved.kind === "authorization" &&
+        (resolved.stopped.ownership !== "cli-owned" || actionOf(resolved.stopped) !== null);
+    return holds
+        ? holdAfterApproval(approved, journey, identity)
+        : applyAndAdvance(approved, journey, resolved.stopped, identity, parsed.answer);
+}
+/**
+ * Everything that decides whether this payload may become a transition.
+ *
+ * Three refusals live together because they answer the same question — "is this
+ * an admissible answer to the boundary in force?" — and none of them writes:
+ * a payload the boundary's own contract rejects, a decline (a real answer that
+ * applies nothing), and an execution result that did not earn its transition.
+ */
+function admit(state, resolved, stopped, input, spent) {
+    const expectedApproval = resolved.kind === "authorization"
+        ? effectApprovalDigest(stopped.id, resolved.authorization?.planned ?? [])
+        : null;
+    const parsed = parseFlowAnswer({
+        raw: input.raw,
+        boundary: resolved.kind,
+        decision: stopped,
+        seal: resolved.seal,
+        choices: resolved.choices,
+        approval: input.approval,
+        expectedApproval,
+        action: resolved.action,
+    });
+    if (!parsed.ok) {
+        // An answer the boundary refused IS an attempt spent: it is the exact event
+        // the chassis' cap counts. Recorded here and nowhere else — a resend, a
+        // decline and a pause are not failed tries at resolving the gap.
+        return {
+            decision: reject(state, resolved, parsed.failure.message, { code: parsed.failure.code, action: parsed.failure.action }, spent),
+        };
+    }
+    // The flow control is a real answer, and neither half applies anything. They
+    // are kept apart because the outcomes differ and the difference is the point:
+    // stopping ends the run here (`cancelled`), pausing keeps the very same
+    // boundary standing so the run picks it up after compacting (`needs_input`).
+    // Collapsing them would report a paused run as a cancelled one.
+    if (parsed.answer.choice === PAUSE_LABEL) {
+        return {
+            decision: reject(state, resolved, `'${PAUSE_LABEL}': la frontera queda en pie y la corrida retoma acá`, {
+                code: "FLOW_BOUNDARY_PAUSED",
+                action: "escribí el CHECKPOINT con 'aw checkpoint-write', compactá, y volvé con 'aw flow advance' a esta misma frontera",
+                outcome: "needs_input",
+            }),
+        };
+    }
+    if (parsed.answer.choice === STOP_LABEL) {
+        return {
+            decision: reject(state, resolved, `'${STOP_LABEL}': el recorrido queda detenido en esta frontera`, {
+                code: "FLOW_BOUNDARY_DECLINED",
+                action: "reanudá con 'aw flow advance' cuando quieras retomar esta frontera",
+                outcome: "cancelled",
+            }),
+        };
+    }
+    // An execution result has to EARN the transition. Anything short of a completed
+    // run with its evidence and its whole effect keeps the boundary standing: the
+    // work stays pending, with the recovery the action declared.
+    if (resolved.kind === "execution") {
+        const verdict = executionVerdict(parsed.answer, resolved.action, effectsOf(stopped));
+        if (verdict !== null) {
+            return { decision: reject(state, resolved, verdict.message, verdict.detail, spent) };
+        }
+    }
+    return parsed;
+}
+/**
+ * Why this execution result does not apply the transition — or `null` when it does.
+ *
+ * Three verdicts, and each one is the answer to a way a run could claim work that
+ * never happened: an outcome that is not `completed` did not finish; evidence that
+ * is missing, failed or empty means nothing came back from the tool; and an effect
+ * ledger short of what the row declared means the invocation got partway. The
+ * recovery the action declared travels in every one of them, because a run stopped
+ * without a next step is the dead end this whole contract refuses.
+ */
+function executionVerdict(answer, action, declared) {
+    const result = answer.result;
+    if (result === null || action === null) {
+        return {
+            message: "la respuesta no trae el resultado de la invocación",
+            detail: {
+                code: "FLOW_RESULT_INVALID",
+                action: "devolvé el resultado real de la acción: outcome, invocación, validaciones y efectos",
+            },
+        };
+    }
+    if (result.outcome !== "completed") {
+        return {
+            message: `la invocación devolvió '${result.outcome}': la transición sigue pendiente`,
+            detail: {
+                code: "FLOW_EXECUTION_NOT_COMPLETED",
+                action: action.recovery,
+                outcome: result.outcome,
+            },
+        };
+    }
+    const missing = action.evidence.filter((id) => {
+        const found = result.validations.find((validation) => validation.id === id);
+        return found === undefined || !found.passed || (found.detail ?? "").trim().length === 0;
+    });
+    if (missing.length > 0) {
+        return {
+            message: `falta la evidencia real de ${missing.join(", ")}`,
+            detail: {
+                code: "FLOW_EVIDENCE_MISSING",
+                action: `devolvé cada validación exigida con 'passed' y su 'detail' — la salida de la herramienta, no una afirmación. ${action.recovery}`,
+            },
+        };
+    }
+    const applied = new Set(result.effects.applied);
+    const partial = declared.filter((effect) => !applied.has(effect));
+    if (partial.length > 0) {
+        return {
+            message: `la invocación declara completa pero no aplicó ${partial.join(", ")}`,
+            detail: {
+                code: "FLOW_EFFECT_PARTIAL",
+                action: action.recovery,
+                outcome: "needs_input",
+            },
+        };
+    }
+    // Completeness is not an outcome — it answers "does what came back cover what
+    // was asked?" — so an attempt that FINISHED can still hand back a partial
+    // output. Ignoring that here would let the run credit a search that returned
+    // half its matches as if it had returned all of them.
+    if (result.output?.completeness === "partial") {
+        return {
+            message: "la invocación terminó pero su salida declara cobertura parcial",
+            detail: {
+                code: "FLOW_EFFECT_PARTIAL",
+                action: action.recovery,
+                outcome: "needs_input",
+            },
+        };
+    }
+    return null;
+}
+/**
+ * Whether the sealed action changed underneath a run that is standing on it.
+ *
+ * Only reachable when the persisted digest and the registry's current one differ —
+ * i.e. the build moved while the caller was executing. Saying so beats the generic
+ * staleness the seal would otherwise report, because the fix is different: nothing
+ * is wrong with the state, the invocation is simply no longer the one that ran.
+ */
+function actionDrift(state, resolved) {
+    const pending = state.pending_action;
+    if (pending === null || resolved.action === null)
+        return null;
+    if (pending.digest === actionDigest(resolved.action))
+        return null;
+    return reject(state, resolved, "la acción de esta frontera cambió después de emitirse: el resultado corresponde a otra invocación", {
+        code: "FLOW_ACTION_CHANGED",
+        action: "volvé a correr 'aw flow advance' para recibir la acción vigente y ejecutá esa antes de responder",
+    });
+}
+/**
+ * Approving an effect is NOT deciding the step, and never executing it.
+ *
+ * The approval is recorded and the run stays exactly where it is: the recalculated
+ * boundary is the one for the SAME transition, so approving what a step exercises
+ * never doubles as deciding it. Applying here would let an approval smuggle in the
+ * step itself.
+ *
+ * On a DELEGATED transition the same hold, for the sharper reason: the approval
+ * authorizes the effect and the recalculated boundary becomes the `execution` one,
+ * which still has to come back with real output. "You may write this" and "this
+ * was written" are different facts, and only the second one advances a run.
+ */
+function holdAfterApproval(approved, journey, identity) {
+    const held = advanceFlowRun({ state: withAttempt(approved, identity), journey, applied: [] });
+    if (!held.ok)
+        return { ok: false, failure: held.failure };
+    return { ok: true, state: held.state, value: held.directive };
+}
+/** The answer survived: the transition applies and the run keeps advancing. */
+function applyAndAdvance(approved, journey, stopped, identity, answer) {
+    // What the agent OBSERVED outlives the boundary it was asked at: a later rule
+    // reads these signals to apply its threshold. The verdict is not stored — it is
+    // derived from these on each read, so the two can never disagree.
+    let next = answer.signals.length > 0
+        ? withObservation(approved, { transition: stopped.id, signals: answer.signals })
+        : approved;
+    next = applyTransition(next, stopped.id, effectsOf(stopped));
+    next = withAttempt(next, identity);
+    // The boundary follows the position, always: handing the engine a state whose
+    // boundary still names the transition just applied is exactly the incoherence
+    // `checkAgainstJourney` exists to refuse.
+    next = withBoundary(next, journey[next.applied.length]?.id ?? null);
+    const advanced = advanceFlowRun({ state: next, journey, applied: [stepOf(stopped)] });
+    if (!advanced.ok)
+        return { ok: false, failure: advanced.failure };
+    return { ok: true, state: advanced.state, value: advanced.directive };
+}
+/**
+ * Whether this submission is a resend, judged by the ledger that already knows
+ * how.
+ *
+ * The persisted history is replayed through {@link AttemptLedger} rather than
+ * counted by hand, so its sequence and parent-linkage rules apply for free — and
+ * a history that cannot be replayed is itself a refusal, not something to work
+ * around. `null` means "a genuinely new attempt: carry on".
+ *
+ * A twin in the history is not enough, and the real walk of the closing tranche
+ * is what showed it. Since refusals started being persisted — and since the seal
+ * stopped moving when one is recorded, so that a caller's own refusal would not
+ * come back as staleness — resending a REFUSED answer looks exactly like
+ * resending an applied one. Both find their twin. Only one of them advanced
+ * anything, and answering the other with "this already applied" reports a run
+ * that is stuck as one that is done: `completed`, with the real cause (a mismatched
+ * approval, an invalid payload) replaced by a vague one, permanently, because
+ * every retry from then on gets the same reply.
+ *
+ * So the twin has to say which it was, and that fact is already in the state:
+ * the run moves past what it applies, so an attempt whose transition is not in
+ * `applied` never advanced anything. Derived rather than stored on the attempt,
+ * for the reason the registry gives everywhere it derives: two sources for one
+ * fact disagree eventually, and then the state is unusable.
+ */
+function resendCheck(state, resolved, identity) {
+    const ledger = new AttemptLedger();
+    for (const past of state.attempts) {
+        const replay = ledger.record(past);
+        if (!replay.ok)
+            return { ok: false, failure: replay.failure };
+    }
+    const verdict = ledger.record(identity);
+    if (!verdict.ok)
+        return { ok: false, failure: verdict.failure };
+    if (verdict.kind === "new")
+        return null;
+    // The TWIN's transition, not this submission's: the identity is built over the
+    // boundary in force, and a resent applied answer is being sent at the next one.
+    // What is being asked is whether the step the twin answered ever moved.
+    const twin = state.attempts.find((past) => past.invocation_id === identity.invocation_id &&
+        past.request_digest === identity.request_digest);
+    // The twin was refused: this is a retry of the same wrong answer, so it gets
+    // the same real diagnosis again and counts toward the cap, which is what
+    // eventually degrades the boundary instead of leaving the caller looping.
+    if (twin !== undefined && !state.applied.includes(twin.transition))
+        return null;
+    return reject(state, resolved, "esta respuesta ya se había aplicado: el recorrido no avanza dos veces", {
+        code: "FLOW_ANSWER_RESENT",
+        action: "la frontera vigente es la que devuelve esta directiva; contestá esa",
+        outcome: "completed",
+    });
+}
+/**
+ * A rejection, expressed as the recalculated directive.
+ *
+ * The state handed back is the one that was read: nothing is written on this
+ * path, and the caller can see that because the mutation returns `ok: false`
+ * only for invocation failures — a business rejection returns the state unchanged
+ * with its own outcome.
+ */
+function reject(state, resolved, message, detail, spent) {
+    // A refused answer is the one rejection that CHANGES the run: the attempt is
+    // recorded, so the boundary that has been tried to its cap degrades instead of
+    // being emitted again. The boundary is recalculated over that state, which is
+    // what turns the last refusal into the degradation rather than into an
+    // identical question with a different error string.
+    const after = spent === undefined ? state : withAttempt(state, spent.identity);
+    const now = spent === undefined ? resolved : resolveBoundary(after, spent.journey);
+    const built = directiveFor(after, now, [], {
+        // No outcome named ⇒ the boundary decides it: a finished journey reports
+        // `completed`, an open one `needs_input`. Hardcoding one here would let a
+        // rejection at the end of a run claim work is still pending.
+        ...(detail.outcome === undefined ? {} : { outcome: detail.outcome }),
+        nextAction: `${message} — ${now.error?.action ?? detail.action}`,
+    });
+    if (!built.ok)
+        return { ok: false, failure: built.failure };
+    // Rewritten with the rejection's own code so the reason is machine-readable and
+    // not only prose in `next_action` — unless the recalculated boundary is itself
+    // blocked, in which case ITS cause is the actionable one: answering again is no
+    // longer a way forward, and reporting the payload's error would suggest it is.
+    const directive = {
+        ...built.directive,
+        error: now.error ?? { code: detail.code, message, action: detail.action },
+    };
+    return { ok: true, state: after, value: directive, persist: spent !== undefined };
+}
+/**
+ * The attempt this submission is, in the terms `AttemptLedger` already validates.
+ *
+ * `invocation_id` is the boundary's seal: stable while the run stands there, and
+ * different the moment the state moves — which is exactly the identity a resend
+ * has to match. Reusing the ledger instead of counting by hand is the point: its
+ * sequence and parent-linkage rules come for free.
+ */
+function attemptIdentity(state, input, seal, transition) {
+    const digest = semanticDigest({ payload: input.raw, approval: input.approval });
+    const prior = state.attempts.filter((past) => past.invocation_id === seal);
+    const twin = prior.find((past) => past.request_digest === digest);
+    const attempt = twin?.attempt ?? prior.length + 1;
+    const parent = attempt === 1
+        ? null
+        : (prior.find((past) => past.attempt === attempt - 1)?.request_digest ?? null);
+    return {
+        invocation_id: seal,
+        attempt,
+        request_digest: digest,
+        parent_request_digest: parent,
+        // The seal moves with the state; the transition does not while the run
+        // stands there. It is what the cap counts over.
+        transition,
+    };
+}
+//# sourceMappingURL=submit.js.map

package/dist/application/flow/submit.js.map

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