@yaag/cli 0.8.2 → 0.9.0

package/assets/types/runtime/ask/ask-exchange-events.d.ts

@@ -12,7 +12,7 @@ export interface AskEndOutcome {
 }
 /**
  * Emits the Ask-scoped Lifecycle Events for one exchange, plus the Agent-scoped
- * `model_fallback` this exchange's fallback loop reports.
+ * `model_fallback` and `agent_model` this exchange's fallback loop reports.
  */
 export declare class AskEvents {
     #private;
@@ -24,6 +24,12 @@ export declare class AskEvents {
     node: (snapshot: NodeSnapshot) => void;
     /** Not Ask-scoped: a fallback names the Agent only, like the spawn-time loop. */
     fallback: (fallback: ModelFallback) => void;
+    /**
+     * The concrete model the Agent runs after a swap that landed (ADR-0041).
+     * Agent-scoped like `fallback`: the pattern side of the story stays in
+     * `model_fallback`, and this carries pi's own `provider/id`.
+     */
+    model: (model: string) => void;
     /** A `normal` cause is the absent default, so ordinary settlements stay lean. */
     end(outcome: AskEndOutcome): void;
 }

package/assets/types/runtime/cassette/run-checkpoint.d.ts

@@ -22,7 +22,8 @@ export interface RunCheckpointOptions {
  * What one publication attempt did. `published` covers both a written artifact
  * and a Run that keeps none. `displaced` carries the error that must become the
  * Run's outcome. `lost` reports a Checkpoint the Run asked for and did not get,
- * while a primary program error keeps the outcome.
+ * while the Run keeps its own outcome — a completed result, or a primary
+ * program error (ADR-0021 amendment).
  */
 export type RunCheckpointResult = {
     readonly kind: "published";

package/assets/types/runtime/events.d.ts

@@ -130,6 +130,19 @@ export type LifecycleEventBody = {
     readonly attempt: number;
     /** The candidate resolution picked next. */
     readonly resolvedModel: string;
+} | {
+    /**
+     * The concrete model an Agent runs from now on, reported when it changes
+     * after spawn. Today the only producer is a successful mid-Ask model swap
+     * (ADR-0038, ADR-0041): `model_fallback` names the pattern the resolver
+     * picked, this names the `provider/id` pi landed on, so `agent.model`
+     * stays concrete. Spawn needs none: `agent_spawn.model` is already
+     * concrete.
+     */
+    readonly type: "agent_model";
+    readonly agent: string;
+    /** pi's concrete `provider/id` for the model the Agent runs now. */
+    readonly model: string;
 } | {
     readonly type: "agent_usage";
     readonly agent: string;

package/assets/types/runtime/model/model-fallback.d.ts

@@ -6,7 +6,10 @@ export interface ModelFallback {
     readonly reason: ModelErrorReason;
     /** 0-based index of the failed attempt in the Agent's shared history. */
     readonly attempt: number;
-    /** The candidate the resolver picked next. */
+    /**
+     * The candidate the resolver picked next. It is a yaag pattern, not a
+     * concrete `provider/id`, so it is never an Agent's model (ADR-0041).
+     */
     readonly resolvedModel: string;
 }
 /** Where a Model Resolution loop reports each fallback it takes. */

package/assets/types/runtime/summary/summary-agent.d.ts

@@ -9,6 +9,11 @@ export type { NodeInfo } from "./summary-nodes.ts";
 export type AgentState = "idle" | "asking" | "exited";
 /** Identity and accounting facts that apply in every observer Agent state. */
 interface AgentInfoBase {
+    /**
+     * Always the concrete `provider/id` pi reports — from `agent_spawn` at spawn
+     * and from `agent_model` after every Model Fallback that landed (ADR-0041).
+     * A `resolvedModel` pattern never lands here.
+     */
     readonly model: string | null;
     readonly cwd: string | null;
     readonly branch: string | null;

package/assets/types/runtime/summary/summary-fallbacks.d.ts

@@ -22,9 +22,8 @@ type ModelFallbackEvent = Extract<LifecycleEventBody, {
  * The Agent's `model` is left alone. `resolvedModel` is a yaag pattern, which
  * can be partial, and the event reports it before the swap is applied, while
  * `model` is pi's resolved `provider/id` for the model the Agent really runs.
- * `agent_spawn` is the only writer of that field: a mid-Ask swap updates the
- * Handle alone and reports no Lifecycle Event, so the Summary keeps the
- * spawn-time id.
+ * Only `agent_spawn` and `agent_model` write that field: a mid-Ask swap that
+ * lands reports the concrete model in its own `agent_model` event (ADR-0041).
  */
 export declare function applyModelFallback(agent: AgentRecord, event: ModelFallbackEvent, at: number | null): AgentRecord;
 export {};

package/assets/types/runtime/summary/summary-model.d.ts

@@ -0,0 +1,16 @@
+import type { LifecycleEventBody } from "../events.ts";
+import type { AgentRecord } from "./summary-agent.ts";
+type AgentModelEvent = Extract<LifecycleEventBody, {
+    readonly type: "agent_model";
+}>;
+/**
+ * Folds the concrete model an Agent runs now (ADR-0041).
+ *
+ * The event reports pi's `provider/id` after a swap landed, so it replaces
+ * `model` and nothing else: a model change is not a lifecycle state change, and
+ * `state`, `askIndex`, `activity`, `stateChangedAt` and the bounded fallback
+ * table stay as they are. An exited Agent is skipped, because its model is
+ * frozen together with its final accounting.
+ */
+export declare function applyAgentModel(agent: AgentRecord, event: AgentModelEvent): AgentRecord;
+export {};

package/assets/types/runtime/transport/fake-transport.d.ts

@@ -45,6 +45,8 @@ export interface FakeTransportOptions extends FakePromptScript {
     readonly schemaCommandError?: string;
     /** The snapshot answered to `get_available_models`; defaults to this fake's own model. */
     readonly models?: readonly AvailableModel[];
+    /** The model this fake reports before any swap; defaults to a placeholder id. */
+    readonly model?: string;
     /** Makes a `set_model` command fail, as pi does for a pair it does not know. */
     readonly setModelError?: string;
     /** Makes a `set_thinking_level` command fail. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaag/cli",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "publishConfig": {
     "access": "public"
   },
@@ -21,8 +21,8 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.84.0",
-    "@yaag/runtime": "0.8.2",
-    "@yaag/tui": "0.8.2",
+    "@yaag/runtime": "0.9.0",
+    "@yaag/tui": "0.9.0",
     "typebox": "1.3.7"
   }
 }

package/src/terminal/render.ts

@@ -41,6 +41,8 @@ function renderPlainEvent(event: LifecycleEventBody, mode: PlainRenderMode): str
     }
     case "model_fallback":
       return `[${event.agent}] model ${event.failedModel} ${event.reason} — falling back to ${event.resolvedModel}`;
+    case "agent_model":
+      return `[${event.agent}] model \u2014 now running ${event.model}`;
     case "agent_exit":
       return `[${event.agent}] exit ${tokens(event.tokens)} ${cost(event.cost)}${event.incomplete ? " (killed mid-ask, cost incomplete)" : ""}`;
     case "run_end": {
@@ -61,6 +63,7 @@ function minimalEvent(type: LifecycleEventBody["type"]): boolean {
     type === "ask_start" ||
     type === "ask_end" ||
     type === "model_fallback" ||
+    type === "agent_model" ||
     type === "agent_exit" ||
     type === "run_end"
   );