@ordewell/core 0.10.3 → 0.10.5

package/dist/{Task-CRVIqSfy.d.ts → Task-D4QHjdGv.d.ts}

@@ -155,8 +155,10 @@ interface IsolationRepo {
     root: string;
     /** The commit checked out at run start. Switching branches mid-run does not retarget it. */
     baseRef: string;
-    /** Branch name checked out at run start; absent on a detached HEAD. */
+    /** Branch name checked out at run start; absent on a detached HEAD, and on a record saved before this was noted. */
     baseBranch?: string;
+    /** Set when the run started on a detached HEAD, so that is told from a record that never noted its branch. */
+    startedDetached?: true;
     integrationBranch: string;
 }
 /**
@@ -237,6 +239,10 @@ interface IsolationHandoffRepo {
     path: string;
     integrationBranch: string;
     baseRef: string;
+    /** The branch the run started on in this repo; absent when it started on a detached HEAD or the record never noted one. */
+    baseBranch?: string;
+    /** Set when the run started on a detached HEAD. */
+    startedDetached?: true;
     /** Tasks whose work landed in this repo, in plan order. */
     landed: IsolationLandedTask[];
 }
@@ -259,27 +265,36 @@ interface IsolationView {
 /**
  * Why "Merge all" would not touch a repo. `partial-landing`: a task's landing
  * was interrupted and could not be rolled back there, so its integration
- * branch holds part of a task.
+ * branch holds part of a task. `wrong-branch`: the repo is not on the branch
+ * the run started on, and the merge would land on some other one.
  */
-type IsolationMergeBlockReason = 'merge-in-progress' | 'conflict' | 'uncommitted-changes' | 'partial-landing' | 'git-error';
+type IsolationMergeBlockReason = 'merge-in-progress' | 'conflict' | 'uncommitted-changes' | 'partial-landing' | 'wrong-branch' | 'git-error';
 interface IsolationMergeBlock {
     repo: string;
     reason: IsolationMergeBlockReason;
     /** The files that would conflict, or the user's uncommitted ones the merge also changes; empty for the other reasons. */
     files: string[];
+    /** `wrong-branch` only: the branch the run started on. */
+    expected?: string;
+    /** `wrong-branch` only: the branch checked out now; absent on a detached HEAD. */
+    actual?: string;
+    /** `wrong-branch` only: the repo is in the middle of a rebase, which is what detached its HEAD. */
+    rebasing?: true;
 }
 /**
  * How "Merge all" went.
  * - `merged`: every repo with work on its integration branch took it.
- * - `blocked`: the preflight found repos that could not, so nothing was
+ * - `blocked`: a repo was on another branch than the run started on, or the
+ *   preflight found repos that could not take their merge, so nothing was
  *   touched anywhere; `blocked` says which and why.
  * - `conflict` / `failed`: a merge stopped in `repo` — on git older than 2.38,
  *   which cannot preflight, or for a reason no preflight could foresee. That
  *   merge was aborted, leaving `repo` as it was; `landed` names the repos
  *   merged before it, which stay merged, and is absent when there are none.
  *
- * A group of one is blocked only by a partial landing; otherwise its one merge
- * lands or is aborted whole, so it reports as it always has.
+ * A group of one is blocked only by a partial landing or by being on the wrong
+ * branch; otherwise its one merge lands or is aborted whole, so it reports as
+ * it always has.
  */
 type IsolationMergeResult = {
     outcome: 'merged';
@@ -463,7 +478,7 @@ interface IWorktreeIsolation {
      * so a crash-recovery prune does not sweep it away; a repair it ends leaves
      * the task `conflict`, as it was before the repair. Takes the run rather than
      * a bare task id: ids are only unique within one plan, and one daemon serves
-     * many (ADR-0007).
+     * many (ADR-0025 D2).
      */
     release(run: IsolationRun, taskId: string, opts: {
         keep: boolean;
@@ -561,7 +576,11 @@ interface UsageRecord {
         amount: number;
         currency: string;
     };
-    /** The model's context window, when the runner itself reports it. */
+    /**
+     * The model's context window: as the runner or provider reported it, or,
+     * when it reported none, from that runner's or provider's own model listing
+     * (`ContextWindowFill`). Never from a table kept in Ordewell.
+     */
     contextWindow?: number;
     /** Set when a subagent made the call; its usage still counts toward the total. */
     subagentId?: string;
@@ -638,16 +657,41 @@ interface ModelUsage {
     totals: UsageTotals;
 }
 declare function addModelUsage(models: readonly ModelUsage[], record: UsageRecord): ModelUsage[];
+/**
+ * What Ordewell has counted of a runner's own session that reports its cost
+ * as a running total: that total and each model's share, in USD, as of its
+ * last report. A resume of that session counts its first report's growth
+ * over this; with no count kept for it, that report only sets the baseline.
+ */
+interface RunnerSessionCost {
+    sessionId: string;
+    usd: number;
+    modelUsd: Record<string, number>;
+}
 interface AttemptUsage extends PlannerUsage {
     attempt: number;
     runner: string;
+    /** The runner session this attempt ran in, as its runner reported it: what a later Continue of it resumes. */
+    sessionId?: string;
     startedAt: string;
     endedAt?: string;
     wallTimeMs: number;
+    /** What was counted of its runner session's running cost as it ended: a continue of that session counts on from it. */
+    runnerSessionCost?: RunnerSessionCost;
 }
 declare function startAttemptUsage(attempt: number, runner: string, startedAt: string): AttemptUsage;
 declare function addAttemptUsage(usage: AttemptUsage, record: UsageRecord, now: string): AttemptUsage;
-declare function endAttemptUsage(usage: AttemptUsage, now: string): AttemptUsage;
+declare function endAttemptUsage(usage: AttemptUsage, now: string, runnerSessionCost?: RunnerSessionCost, sessionId?: string): AttemptUsage;
+/** The count a continue of `sessionId` starts from: the one its latest attempt in that session ended with. */
+declare function countedSessionCost(attempts: readonly AttemptUsage[] | undefined, sessionId: string): RunnerSessionCost | undefined;
+/**
+ * The model a continue's session last ran on and the window it was measured
+ * against: the latest earlier attempt of that same runner session that
+ * reported one. An attempt that measured nothing is skipped — a continuation
+ * does not undo what its session was last measured against — and a window is
+ * never borrowed from another session: a fresh attempt starts one.
+ */
+declare function resumedSessionWindow(attempts: readonly AttemptUsage[] | undefined, runner: string, attempt: number, sessionId: string): Pick<PlannerUsage, 'source' | 'model' | 'contextWindow'> | undefined;
 interface PlanUsage {
     totals: UsageTotals;
     byModel: ModelUsage[];
@@ -660,6 +704,21 @@ interface UsageTask {
     subtasks?: readonly UsageTask[];
 }
 declare function planUsage(tasks: readonly UsageTask[]): PlanUsage;
+/**
+ * What one task spent across every attempt and every model it ran on, so a
+ * stop, a model change and a continue never makes the earlier spend vanish. The
+ * context meter is the exception: it reads the latest attempt, because only the
+ * current model's window says how full the next prompt is.
+ */
+interface TaskUsageSummary {
+    totals: UsageTotals;
+    attempts: number;
+    contextFill?: {
+        usedTokens: number;
+        windowTokens: number;
+    };
+}
+declare function taskUsageSummary(task: Pick<UsageTask, 'attemptUsage'>): TaskUsageSummary;
 
 /**
  * How far a plan's supervisor may act in its wake-up turns (ADR-0029): a plan
@@ -993,6 +1052,13 @@ interface Task {
     userStoriesCovered?: string[];
     /** The runner's saved session for a later continue; cleared when a fresh attempt starts. */
     runnerSessionId?: string;
+    /**
+     * The runner that session belongs to: a session cannot cross runners, so
+     * Continue is offered only while the task is still assigned to it. Absent
+     * on a plan saved before it was recorded; the last attempt's runner stands
+     * in (see `sessionOwner`).
+     */
+    runnerSessionOwner?: RunnerId;
     /** Set only while `status` is `awaiting_user`, and not always then — a pause saved by an older build has none. */
     awaitingReason?: AwaitingReason;
     /**
@@ -1177,10 +1243,13 @@ interface ConversationMessage {
      * (ADR-0029), its record in `execution`. 'wake_up' is the digest a wake-up
      * gave the supervisor (role 'user': the model was told it), and
      * 'supervisor' what the supervisor said in a wake-up turn (ADR-0029).
+     * 'error' is a planner turn that ended on the planner's usage limit, drawn
+     * as a failure and never replayed to the planner: it is not the planner's
+     * answer, and its inputs are sent again (see {@link PlannerResendState}).
      * Absent for ordinary chat turns, so sessions saved before markers existed
      * degrade gracefully.
      */
-    kind?: 'plan_generated' | 'system' | 'compaction' | 'skill_load' | 'execution' | 'wake_up' | 'supervisor';
+    kind?: 'plan_generated' | 'system' | 'compaction' | 'skill_load' | 'execution' | 'wake_up' | 'supervisor' | 'error';
     actor?: 'Ordewell setting';
     /** Present exactly when `kind` is 'skill_load'. */
     skill?: SkillLoad;
@@ -1268,6 +1337,17 @@ interface SupervisionSnapshot {
     /** The events inside their debounce window and the wake-up rate's timestamps. */
     wake?: SupervisorSnapshot;
 }
+/**
+ * What waits on the planner's usage limit. With `at`, the inputs no turn
+ * answered are sent again then, on their own; without it — the reset could
+ * not be read, the resend hit the limit again, or it was cancelled — they go
+ * with the next input: the user's message, or a wake-up.
+ */
+interface PlannerResendState {
+    /** The runner whose account hit the limit; a planner on another one is not held by it. */
+    runner?: RunnerId;
+    at?: string;
+}
 interface LegacyPlanState {
     runSettings?: RunSettings;
     /** What supervision remembers across a daemon restart (ADR-0029); absent on plans saved before it existed. */
@@ -1295,6 +1375,8 @@ interface LegacyPlanState {
     isolation?: PlanIsolation;
     /** Kept so a reopened session shows the same token line (#49). */
     plannerUsage?: PlannerUsage;
+    /** The planner hit its usage limit and the inputs its turn took wait to be sent again; absent otherwise. */
+    plannerResend?: PlannerResendState;
     /**
      * The tasks the user approved to run: every task when they executed the
      * plan, and each one they started or retried themselves since. A command
@@ -1385,4 +1467,4 @@ type ApprovalRecord = Pick<LegacyPlanState, 'approved' | 'approvedTasks'>;
  */
 declare function waitsForApproval(task: Pick<Task, 'id' | 'type' | 'status'>, record: ApprovalRecord): boolean;
 
-export { type ResearchStepOutcome as $, type ApprovalRecord as A, BUILTIN_SKILL_NAMES as B, type ConversationMessage as C, DEFAULT_RUNNERS as D, type ExecutionActor as E, type IsolationTaskStatus as F, type GuardTarget as G, type IsolationView as H, type IWorktreeIsolation as I, type PlanIsolation as J, type PlanState as K, type LegacyPlanState as L, type ModelUsage as M, type PlanStatus as N, type PlanUsage as O, type PendingPlanTurn as P, type PlannerUsage as Q, type PrepareIntent as R, type PreparedTask as S, type PreservedWork as T, type PreviousWork as U, type RefusedRemoval as V, type RepairEvidence as W, type RepoGroupLayout as X, type ResearchLogEntry as Y, type ResearchProgress as Z, type ResearchStep as _, type AttemptUsage as a, type ResearchToolType as a0, type RunSettings as a1, type RunnerId as a2, type SetupFailure as a3, type ShadowedSkill as a4, type SkillAppliesTo as a5, type SkillCatalog as a6, type SkillInfo as a7, type SkillLoad as a8, type SkillLoadNotice as a9, createEmptyPlan as aA, createSkillsService as aB, createTask as aC, endAttemptUsage as aD, flattenTasks as aE, flattenTasksWithParents as aF, isAwaitingReason as aG, isMeasured as aH, isSupervisorLevel as aI, isUserMessage as aJ, migratePlanState as aK, partedPromptUsage as aL, pausedOnLimit as aM, planUsage as aN, plannerContextFill as aO, rejoinPlanTree as aP, startAttemptUsage as aQ, usageLine as aR, waitsForApproval as aS, type SkillMetadata as aa, type SkillSource as ab, SkillsService as ac, type SubagentOutcome as ad, type SupervisorLevel as ae, type Task as af, type TaskDiffRead as ag, type TaskDiffResult as ah, type TaskIsolation as ai, type TaskIsolationState as aj, type TaskModelAssignment as ak, type TaskSkillNotice as al, type TaskSkillSnapshot as am, type TaskSnapshot as an, type TaskStatus as ao, type TreeSnapshot as ap, type UsageLine as aq, type UsageRecord as ar, type UsageTotals as as, type Verdict as at, type VerificationCheck as au, addAttemptUsage as av, addModelUsage as aw, addPlannerUsage as ax, addUsage as ay, addUsageTotals as az, type AwaitingReason as b, DEFAULT_SUPERVISOR_RETRY_LIMIT as c, type DiscoveredModel as d, type ExecutionCommandName as e, type ExecutionRecord as f, type GuardTrip as g, type IntegrationDisposal as h, type InvalidSkill as i, type IsolationAvailability as j, type IsolationHandoff as k, type IsolationHandoffRepo as l, type IsolationInactiveReason as m, type IsolationLandedTask as n, type IsolationLanding as o, type IsolationMergeBlock as p, type IsolationMergeBlockReason as q, type IsolationMergeResult as r, type IsolationOutcome as s, type IsolationPruneResult as t, type IsolationRemoval as u, type IsolationRepo as v, type IsolationRun as w, type IsolationTaskRecord as x, type IsolationTaskRef as y, type IsolationTaskRepo as z };
+export { type ResearchStep as $, type ApprovalRecord as A, BUILTIN_SKILL_NAMES as B, type ConversationMessage as C, DEFAULT_RUNNERS as D, type ExecutionActor as E, type IsolationTaskStatus as F, type GuardTarget as G, type IsolationView as H, type IWorktreeIsolation as I, type PlanIsolation as J, type PlanState as K, type LegacyPlanState as L, type ModelUsage as M, type PlanStatus as N, type PlanUsage as O, type PendingPlanTurn as P, type PlannerResendState as Q, type PlannerUsage as R, type PrepareIntent as S, type PreparedTask as T, type PreservedWork as U, type PreviousWork as V, type RefusedRemoval as W, type RepairEvidence as X, type RepoGroupLayout as Y, type ResearchLogEntry as Z, type ResearchProgress as _, type AttemptUsage as a, type ResearchStepOutcome as a0, type ResearchToolType as a1, type RunSettings as a2, type RunnerId as a3, type RunnerSessionCost as a4, type SetupFailure as a5, type ShadowedSkill as a6, type SkillAppliesTo as a7, type SkillCatalog as a8, type SkillInfo as a9, addPlannerUsage as aA, addUsage as aB, addUsageTotals as aC, countedSessionCost as aD, createEmptyPlan as aE, createSkillsService as aF, createTask as aG, endAttemptUsage as aH, flattenTasks as aI, flattenTasksWithParents as aJ, isAwaitingReason as aK, isMeasured as aL, isSupervisorLevel as aM, isUserMessage as aN, migratePlanState as aO, partedPromptUsage as aP, pausedOnLimit as aQ, planUsage as aR, plannerContextFill as aS, rejoinPlanTree as aT, resumedSessionWindow as aU, startAttemptUsage as aV, taskUsageSummary as aW, usageLine as aX, waitsForApproval as aY, type SkillLoad as aa, type SkillLoadNotice as ab, type SkillMetadata as ac, type SkillSource as ad, SkillsService as ae, type SubagentOutcome as af, type SupervisorLevel as ag, type Task as ah, type TaskDiffRead as ai, type TaskDiffResult as aj, type TaskIsolation as ak, type TaskIsolationState as al, type TaskModelAssignment as am, type TaskSkillNotice as an, type TaskSkillSnapshot as ao, type TaskSnapshot as ap, type TaskStatus as aq, type TaskUsageSummary as ar, type TreeSnapshot as as, type UsageLine as at, type UsageRecord as au, type UsageTotals as av, type Verdict as aw, type VerificationCheck as ax, addAttemptUsage as ay, addModelUsage as az, type AwaitingReason as b, DEFAULT_SUPERVISOR_RETRY_LIMIT as c, type DiscoveredModel as d, type ExecutionCommandName as e, type ExecutionRecord as f, type GuardTrip as g, type IntegrationDisposal as h, type InvalidSkill as i, type IsolationAvailability as j, type IsolationHandoff as k, type IsolationHandoffRepo as l, type IsolationInactiveReason as m, type IsolationLandedTask as n, type IsolationLanding as o, type IsolationMergeBlock as p, type IsolationMergeBlockReason as q, type IsolationMergeResult as r, type IsolationOutcome as s, type IsolationPruneResult as t, type IsolationRemoval as u, type IsolationRepo as v, type IsolationRun as w, type IsolationTaskRecord as x, type IsolationTaskRef as y, type IsolationTaskRepo as z };

package/dist/{chunk-A57ITQE7.mjs → chunk-4QLFM73A.mjs}

@@ -12,7 +12,7 @@ import {
   resolveTaskRef,
   skillNames,
   updateTaskInPlan
-} from "./chunk-SM6BV6XS.mjs";
+} from "./chunk-RT4NQ2BZ.mjs";
 
 // src/services/JsonExtractor.ts
 var PLAN_ENVELOPE_KEY = "tasks";
@@ -301,7 +301,7 @@ function blockedByLabel(refs) {
 function skippedLabel(reason) {
   return reason ? `Skipped: ${reason}` : "Skipped";
 }
-var WAITS_FOR_APPROVAL_LABEL = "Waiting for your approval to start";
+var WAITS_FOR_APPROVAL_LABEL = "Waits for your approval";
 function approvalLabel(count) {
   if (!count) return null;
   return count > 1 ? `Waiting for approval (${count})` : "Waiting for approval";
@@ -369,7 +369,14 @@ function clampThinkingEffort(effort, variants) {
   }
   return void 0;
 }
-function coerceAssignments(tasks, perRunnerAllowlist, modelsByRunner) {
+function coerceAssignments(tasks, perRunnerAllowlist, modelsByRunner, planned = []) {
+  const prior = new Map(flattenTasks(planned).map((t) => [t.id, t]));
+  const unwritten = (task) => {
+    const was = prior.get(task.id);
+    if (!was?.assignedModel || !task.assignedModel || was.assignedRunner !== task.assignedRunner) return void 0;
+    if (was.assignedModel.modelId !== task.assignedModel.modelId || was.assignedModel.thinkingEffort !== task.assignedModel.thinkingEffort) return void 0;
+    return was;
+  };
   const clampVariant = (task) => {
     if (!task.assignedModel || !modelsByRunner) return task;
     const model = modelsByRunner[task.assignedRunner]?.find(
@@ -398,6 +405,11 @@ function coerceAssignments(tasks, perRunnerAllowlist, modelsByRunner) {
   };
   const coerceOne = (task) => {
     if (task.type === "user") return task;
+    const kept = unwritten(task);
+    if (kept) {
+      const left = { ...task, assignedModel: kept.assignedModel };
+      return kept.status === "in_progress" || kept.status === "awaiting_user" ? left : clampVariant(left);
+    }
     const allowlist = allowedFor(task.assignedRunner);
     if (!task.assignedModel) {
       if (allowlist && allowlist.length > 0) {
@@ -594,6 +606,15 @@ function lockedTaskRefusal(task, action = "changed") {
   if (task.status === "completed") return `"${task.title}" is completed and cannot be ${action}: rearm it to run it again, or add a new task for further work`;
   return null;
 }
+function liveModelRefusal(task) {
+  return `"${task.title}" has a live runner, so its model and effort cannot change now: stop the task first, or use the runner's own /model`;
+}
+function liveRunnerRefusal(task) {
+  return `"${task.title}" has a live runner, so its runner cannot change now: stop the task first`;
+}
+function sameAssignment(a, b) {
+  return a?.modelId === b?.modelId && a?.thinkingEffort === b?.thinkingEffort;
+}
 var AI_ONLY_FIELDS = ["assignedModel", "taskMode", "autonomy", "ops"];
 function checkModelAndModeValidity(runner, assignedModel, taskMode, catalog) {
   if (!catalog) return { ok: true };
@@ -653,11 +674,18 @@ function validateTaskEdit(actor, tasks, taskId, changes, catalog) {
   const { task: target, parent } = found;
   const locked = actor === "planner" ? lockedTaskRefusal(target, "modified") : null;
   if (locked) return { ok: false, error: locked };
+  const coherence = typeCoherenceCheck(target, changes);
+  const landing = coherence?.clear?.includes("assignedModel") ? { ...changes, assignedModel: void 0 } : changes;
+  if ("assignedModel" in landing && !sameAssignment(landing.assignedModel, target.assignedModel) && catalog?.liveRunner?.(taskId)) {
+    return { ok: false, error: liveModelRefusal(target) };
+  }
+  if ("assignedRunner" in changes && changes.assignedRunner !== target.assignedRunner && catalog?.liveRunner?.(taskId)) {
+    return { ok: false, error: liveRunnerRefusal(target) };
+  }
   if (changes.dependencies) {
     const depCheck = canSetDependencies(parent?.subtasks ?? tasks, taskId, changes.dependencies);
     if (!depCheck.ok) return depCheck;
   }
-  const coherence = typeCoherenceCheck(target, changes);
   if (coherence && !coherence.ok) return coherence;
   const ops = opsCheck(target, parent !== null, changes);
   if (ops) return ops;
@@ -1363,6 +1391,7 @@ export {
   requestedSkills,
   plannedTask,
   checkPlanInvariants,
+  liveRunnerRefusal,
   validateTaskEdit,
   UPDATABLE_FIELDS,
   taskOpsProtocol,
@@ -1375,4 +1404,4 @@ export {
   canSplitTask,
   applyTaskOps
 };
-//# sourceMappingURL=chunk-A57ITQE7.mjs.map
+//# sourceMappingURL=chunk-4QLFM73A.mjs.map