@vincemakes/kiso-runtime 0.39.2 → 0.40.1

package/dist/profile.js

@@ -40,6 +40,7 @@ export function buildProfile(input) {
         modelId: input.modelId,
         provider: input.provider,
         profileName: input.profileName ?? null,
+        workspace: input.workspace ?? null,
         reasoning: input.reasoning ?? { thinking: "default", effort: "default" },
         systemPromptDigest: sha(input.systemPrompt ?? ""),
         tools,
@@ -49,10 +50,37 @@ export function buildProfile(input) {
 export function profilePath(root, sessionId) {
     return join(root, `${sessionId}.meta.json`);
 }
+/** The sidecar's tenants as they are on disk NOW — the writer of one
+ *  tenant carries the other's bytes through untouched. An unreadable file
+ *  yields {}: the writer that follows replaces it (the profile path's own
+ *  fail-closed read is readProfile, which a writer never bypasses). */
+function currentTenants(root, sessionId) {
+    try {
+        const parsed = JSON.parse(readFileSync(profilePath(root, sessionId), "utf8"));
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
 /** Atomic, fail-closed write: a reader sees the previous revision or the
  *  new one, never a torn file — and the RENAME itself is made durable by
- *  the parent-directory fsync. */
+ *  the parent-directory fsync. 0.40.0 dogfood: the file holds two tenants
+ *  (`profile`, `summary`); writing one preserves the other. */
 export function writeProfile(root, sessionId, profile) {
+    writeTenants(root, sessionId, { ...currentTenants(root, sessionId), profile });
+}
+/** The 0.40.0 dogfood's `summary` tenant — what the session list reads
+ *  instead of the log. Preserves the `profile` tenant byte for byte. */
+export function writeSummary(root, sessionId, summary) {
+    writeTenants(root, sessionId, { ...currentTenants(root, sessionId), summary });
+}
+/** The summary tenant, or null (no sidecar, no summary, or unreadable). */
+export function readSummary(root, sessionId) {
+    const t = currentTenants(root, sessionId).summary;
+    return t !== undefined && typeof t.updatedAt === "number" ? t : null;
+}
+function writeTenants(root, sessionId, tenants) {
     const path = profilePath(root, sessionId);
     const tmpDir = mkdtempSync(join(root, ".meta-"));
     const tmp = join(tmpDir, "meta.json");
@@ -61,7 +89,7 @@ export function writeProfile(root, sessionId, profile) {
         // because rename preserves it, and rename is the only path by which
         // this file comes into existence. Existing files are not migrated —
         // R6's choice, kept.
-        writeFileSync(tmp, `${JSON.stringify({ profile }, null, "\t")}\n`, { mode: 0o600 });
+        writeFileSync(tmp, `${JSON.stringify(tenants, null, "\t")}\n`, { mode: 0o600 });
         const fd = openSync(tmp, "r");
         try {
             fsyncSync(fd);
@@ -95,6 +123,11 @@ export function readProfile(root, sessionId) {
     }
     try {
         const parsed = JSON.parse(raw);
+        // 0.40.0 dogfood: a sidecar that holds ONLY the summary tenant (a legacy
+        // session the list summarised) has no profile — absent, never corrupt:
+        // "corrupt" BLOCKS the session from opening, and nothing is wrong
+        if (parsed !== null && typeof parsed === "object" && !("profile" in parsed))
+            return { kind: "absent" };
         const p = parsed.profile;
         if (p === undefined ||
             typeof p.revision !== "number" ||
@@ -105,7 +138,13 @@ export function readProfile(root, sessionId) {
             !Array.isArray(p.tools)) {
             return { kind: "corrupt", error: "the profile tenant is missing or malformed" };
         }
-        return { kind: "ok", profile: p };
+        // 0.40.0: a sidecar written before `workspace` existed (and one whose
+        // `profileName` no writer ever filled) reads as null — unknown, never
+        // a guess. The reader stays open: no new key is required.
+        return {
+            kind: "ok",
+            profile: { ...p, profileName: typeof p.profileName === "string" ? p.profileName : null, workspace: typeof p.workspace === "string" ? p.workspace : null },
+        };
     }
     catch (err) {
         return { kind: "corrupt", error: String(err.message ?? err) };
@@ -115,8 +154,9 @@ export function readProfile(root, sessionId) {
  *  never from digest inequality alone: every recorded tool present with
  *  identical hashes plus new names = compatible additions (a one-line
  *  notice); a missing name, a changed hash, a provider/model divergence,
- *  or a system-prompt divergence = MATERIAL (explicit resolution; a
- *  digest mismatch is never presented as restoration). */
+ *  or a system-prompt divergence = MATERIAL (the change is NAMED and
+ *  recorded as the next revision under the CURRENT configuration — it
+ *  blocks nothing; a digest mismatch is never presented as restoration). */
 export function assessProfileDrift(recorded, current) {
     const reasons = [];
     const notes = [];
@@ -125,8 +165,29 @@ export function assessProfileDrift(recorded, current) {
     if ((r === null) !== (c === null)) {
         reasons.push(`the recorded binding is ${r === null ? "unscoped" : `${r.providerId}/${r.modelId}`} but the current process serves ${c === null ? "an unscoped adapter" : `${c.providerId}/${c.modelId}`}`);
     }
-    else if (r !== null && c !== null && r.providerId !== c.providerId) {
-        reasons.push(`the recorded provider is ${r.providerId} but the current process serves ${c.providerId}`);
+    else if (r !== null && c !== null) {
+        // WHO ANSWERS is an identity, and `providerId` alone is not one:
+        // `custom` names a CLASS — two custom endpoints are two different
+        // places to spend — so an endpoint (or API flavour) that moved is a
+        // changed binding like any other. Found in review of this round.
+        if (r.providerId !== c.providerId)
+            reasons.push(`the recorded provider is ${r.providerId} but the current process serves ${c.providerId}`);
+        if (r.apiId !== c.apiId)
+            reasons.push(`the recorded API is ${r.apiId} but the current process serves ${c.apiId}`);
+        if ((r.endpoint ?? null) !== (c.endpoint ?? null))
+            reasons.push(`the recorded endpoint is ${r.endpoint ?? "(none)"} but the current process serves ${c.endpoint ?? "(none)"}`);
+    }
+    // THE MODEL TOO — the owner's ruling of 2026-09-21, taken on review: the
+    // CONFIGURATION wins, including a model switch inside one provider (`--model`
+    // and the config are never silently ignored on a resume). This is compared
+    // even when BOTH sides are unscoped, where there is no provider ref to carry
+    // it, and it covers the ref's own `modelId` as well (the same fact, stamped
+    // by the same builder).
+    if (r !== null && c !== null && (r.modelId !== c.modelId || recorded.modelId !== current.modelId)) {
+        reasons.push(`the recorded model is ${recorded.modelId} but the current process serves ${current.modelId}`);
+    }
+    else if (r === null && c === null && recorded.modelId !== current.modelId) {
+        reasons.push(`the recorded model is ${recorded.modelId} but the current process serves ${current.modelId} (both bindings are unscoped)`);
     }
     if (recorded.systemPromptDigest !== current.systemPromptDigest) {
         notes.push(`the composed system prompt differs from the recorded one (${recorded.systemPromptDigest.slice(0, 12)}… → ${current.systemPromptDigest.slice(0, 12)}…)`);

package/dist/run.d.ts

@@ -13,7 +13,7 @@ import { type AgentSession, type SessionConfig } from "./session.js";
 export declare class Run implements AsyncIterable<Event> {
     #private;
     runId: string;
-    constructor(store: SessionStore, adapter: Adapter, config: SessionConfig, session: AgentSession, input: string | readonly ContentBlock[] | undefined, externalSignal: AbortSignalLike | undefined, resume: boolean, source?: import("@vincemakes/kiso-core").MessageSource);
+    constructor(store: SessionStore, adapter: Adapter, config: SessionConfig, session: AgentSession, input: string | readonly ContentBlock[] | undefined, externalSignal: AbortSignalLike | undefined, resume: boolean, source?: import("@vincemakes/kiso-core").MessageSource, via?: import("@vincemakes/kiso-core").UserInputVia);
     /** Cancel the run: propagates to the adapter (SDK) and future executions. */
     abort(): void;
     [Symbol.asyncIterator](): AsyncIterator<Event>;

package/dist/run.js

@@ -7,7 +7,7 @@ import { denialResult, loop } from "@vincemakes/kiso-core";
 import { ABORTED, MergedSignal, abortable, openRunId } from "./recovery.js";
 import { resolveReasoning } from "./provider/metadata.js";
 import { deriveRecoveryPlan, invocationSeqOf } from "./recovery-plan.js";
-import { composeApprovalChain, composeSystemPrompt, composeToolTable, microcompactFor } from "./compose.js";
+import { composeApprovalChain, composeSystemPrompt, runBasePrompt } from "./compose.js";
 import { truncationGuard } from "./truncation-guard.js";
 import { DEFAULT_STREAM_IDLE_MS, idleGuard } from "./idle-guard.js";
 import { RequestTracer, traceGuard } from "./trace/guard.js";
@@ -30,6 +30,7 @@ export class Run {
     #input;
     #resume;
     #source;
+    #via;
     #abort = new AbortController();
     #externalSignal;
     #decisionIds = [];
@@ -38,7 +39,10 @@ export class Run {
     // TV-1B: durable PROVENANCE for the input (e.g. the verification
     // seed's source:"system") — who produced the line, never a
     // provider-role escalation. Absent = plain user input.
-    source) {
+    source, 
+    // 0.40.0: how a person composed the turn (a skill + the typed line) —
+    // recorded for display, never projected into a request.
+    via) {
         this.#store = store;
         this.#adapter = adapter;
         this.#config = config;
@@ -47,6 +51,7 @@ export class Run {
         this.#externalSignal = externalSignal;
         this.#resume = resume;
         this.#source = source;
+        this.#via = via;
         this.runId = crypto.randomUUID();
     }
     /** Cancel the run: propagates to the adapter (SDK) and future executions. */
@@ -77,10 +82,7 @@ export class Run {
             // session's base prompt and the extension appends: generated
             // machinery never outranks the deliberate extension text (the E2
             // "append lands at the END" contract holds). "" when empty.
-            const toolTable = composeToolTable(this.#config.registry);
-            const basePrompt = toolTable === "" ? this.#config.systemPrompt
-                : this.#config.systemPrompt === undefined ? toolTable
-                    : `${this.#config.systemPrompt}\n\n${toolTable}`;
+            const basePrompt = runBasePrompt(this.#config.systemPrompt, this.#config.registry);
             // E3 — the ledger's parts: the base as CONFIGURED (what the CLI
             // handed the runtime — the tool table is generated machinery, R3)
             // and the extension appends in load order (R4 attribution). The
@@ -113,12 +115,30 @@ export class Run {
             // extension providing a compaction config supplies it. E6: the
             // contextPolicy override beats the session's own, and its minTurns
             // no-fire guard may omit the config below the floor.
-            const microcompact = microcompactFor(this.#config, log.all);
             // E2: the session's own systemPrompt first, then every extension
             // append in LOAD order — deterministic (same extensions → same
             // prompt); no appends → byte-identical to the extension-less run.
             const systemPrompt = composeSystemPrompt(basePrompt, this.#config.extensions ?? []);
             const approvalChain = composeApprovalChain(this.#config.extensions ?? []);
+            // ADR-0055 Amendment 1 (A1b): the compaction point the kernel asks
+            // before every request — the run's own prefix, so an in-band
+            // summary reads it at the cache-hit price.
+            // The loop resolves the same setting when it builds each request; a
+            // setting that cannot run refuses the run there, before any compaction.
+            let wireReasoning;
+            try {
+                wireReasoning = this.#config.reasoning !== undefined ? resolveReasoningOrThrow(this.#config.model, this.#config.reasoning, this.#config.baseUrl).reasoning : undefined;
+            }
+            catch {
+                wireReasoning = undefined;
+            }
+            const compact = this.#session.compactionPoint({
+                ...(systemPrompt !== undefined ? { systemPrompt } : {}),
+                tools: () => this.#config.registry.snapshot().specs,
+                ...(wireReasoning !== undefined ? { reasoning: wireReasoning } : {}),
+                signal,
+                ...(this.#config.maxRetries !== undefined ? { maxRetries: this.#config.maxRetries } : {}),
+            });
             const loopConfig = () => ({
                 // 0.1.40 (R-C item 3): the truncation guard gates the model
                 // stream — a truncated turn's tool batch never executes.
@@ -134,7 +154,7 @@ export class Run {
                 ...(this.#config.maxTurns !== undefined ? { maxTurns: this.#config.maxTurns } : {}),
                 ...(this.#config.maxTokens !== undefined ? { maxTokens: this.#config.maxTokens } : {}),
                 ...(this.#config.temperature !== undefined ? { temperature: this.#config.temperature } : {}),
-                ...(microcompact !== undefined ? { microcompact } : {}),
+                ...(compact !== undefined ? { compact } : {}),
                 ...(this.#config.maxRetries !== undefined ? { maxRetries: this.#config.maxRetries } : {}),
                 // MG-1 (A5): the kernel stamps committed envelopes with this.
                 ...(this.#config.continuationScope !== undefined ? { continuationScope: this.#config.continuationScope } : {}),
@@ -265,8 +285,11 @@ export class Run {
             //    session. The prompt is also the first event the consumer
             //    sees, so what was asked and what happened live in the same
             //    stream.
-            const inputEvent = log.append({ type: "user_input", content: this.#input, ...(this.#source !== undefined ? { source: this.#source } : {}) });
+            const inputEvent = log.append({ type: "user_input", content: this.#input, ...(this.#source !== undefined ? { source: this.#source } : {}), ...(this.#via !== undefined ? { via: this.#via } : {}) });
             await this.#session.persist(this.runId, inputEvent);
+            // 0.40.0 dogfood: the list's row says "open" from here — a run
+            // killed mid-way reads as interrupted, which is the truth
+            this.#session.recordSummary(true);
             yield inputEvent;
             // 2. The loop projects from the session log — multi-turn context
             //    is the projection, not a second copy.
@@ -285,6 +308,9 @@ export class Run {
                 // the flush itself failed (poisoned session) — the error
                 // already poisoned everything; nothing more can be done.
             }
+            // 0.40.0 dogfood: the row at the run's end — its terminal, or the
+            // pause it stopped at (pending asks counted); best-effort
+            this.#session.recordSummary(this.#session.log.all.at(-1)?.type !== "terminal");
             // The run is over (or abandoned): its unanswered approvals must
             // fall back to the direct-persist path, so a late approve() is
             // still durable.

package/dist/session-summary.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The 0.40.0 dogfood (item 2) — a session's SUMMARY, the one thing the
+ * session list reads.
+ *
+ * The list used to read every session's whole event log, three times, to
+ * draw one row each: on the owner's machine that is 118 sessions, 584 MB,
+ * 3.58M events, about 8.3 s before the picker appears. The sidecar the
+ * session already keeps (`<id>.meta.json`) is read in 2 ms for all 118. So
+ * the list reads the sidecar ONLY, and the sidecar carries what the row
+ * shows, as its own tenant beside the execution profile:
+ *
+ *   title, turns, last activity, state (open or the terminal's outcome),
+ *   uncertain executions, pending asks, whether the workspace is unknown,
+ *   and where the summary came from (a run, or the one-time migration).
+ *
+ * The runtime writes it at a run's start (state open — a run killed there
+ * reads "interrupted" in the list, which is the truth) and at its end. It
+ * is OBSERVATION: nothing in recovery, projection or a request reads it
+ * (the §6 purity rule), and a failed write never fails a run.
+ *
+ * `sessionSummary` is a pure function of the durable records, shared by the
+ * live writes and the one-time migration so the two can never disagree.
+ */
+import type { Event } from "@vincemakes/kiso-core";
+import { type StoreRecord } from "./store.js";
+export interface SessionSummary {
+    /** the session's first substantive prompt (`sessionTitle`); null when unknown */
+    readonly title: string | null;
+    /** user turns; null when unknown (an unreadable log) */
+    readonly turns: number | null;
+    /** ms since the epoch — the last record's stamp, or the file's mtime */
+    readonly updatedAt: number;
+    /** "open" while a run has no terminal event; else the terminal's outcome kind */
+    readonly state: string | null;
+    readonly uncertain: number;
+    readonly asks: number;
+    /** the profile records no workspace (a session from before 0.40.0) */
+    readonly workspaceUnknown: boolean;
+    /** "run" — written by a run; "migration" — the one-time pass over a legacy log */
+    readonly source: "run" | "migration";
+}
+/** The summary of a session's events — the core both writers share.
+ *  `open`, `updatedAt` and `asks` come from whoever knows them: a live
+ *  session knows its own run and its resolvers; the migration derives
+ *  them from the records. */
+export declare function summarizeEvents(events: readonly Event[], opts: {
+    open: boolean;
+    updatedAt: number;
+    asks: number;
+    workspaceUnknown: boolean;
+    source: "run" | "migration";
+}): SessionSummary;
+/** The summary of a session's durable RECORDS — the one-time migration's
+ *  input (a legacy log read exactly once, never through a live session). */
+export declare function sessionSummary(records: readonly StoreRecord[], opts: {
+    workspaceUnknown: boolean;
+    source: "run" | "migration";
+    fallbackUpdatedAt?: number;
+}): SessionSummary;
+/** The migration's marker: written once every legacy session has a
+ *  summary. From then on the list never reads a log (lead's ruling A): a
+ *  session still without a summary shows "no summary". */
+export declare const SUMMARY_MIGRATION_MARKER = ".summaries-migrated";
+export interface SessionListing {
+    readonly id: string;
+    /** the log file's mtime — the last-activity fallback, never a guess at content */
+    readonly mtime: number;
+    readonly summary: SessionSummary | null;
+    readonly workspace: string | null;
+    readonly profileName: string | null;
+}
+/** Every session in `root`, from the DIRECTORY and the sidecars only — no
+ *  log is opened. The 0.40.0 dogfood's list path. */
+export declare function listSessionSidecars(root: string): SessionListing[];
+/** Whether the one-time migration still has work: the marker is absent. */
+export declare function summaryMigrationPending(root: string): boolean;
+/**
+ * The ONE-TIME migration (lead's ruling A). Each session without a summary
+ * has its log read exactly once — through the store's plain loader, never a
+ * live session, so the profile contract cannot throw it — and its summary
+ * written with `source: "migration"`. A log that cannot be read gets what
+ * CAN be said (last activity from the file's mtime; title and turns
+ * unknown) and never throws the list. Resumable: each summary is written on
+ * its own, so a crash mid-way leaves the done ones done; the marker lands
+ * only when every session has one.
+ */
+export declare function migrateSummaries(root: string, load: (id: string) => readonly StoreRecord[], onEach?: (done: number, total: number) => void): number;

package/dist/session-summary.js

@@ -0,0 +1,166 @@
+/**
+ * The 0.40.0 dogfood (item 2) — a session's SUMMARY, the one thing the
+ * session list reads.
+ *
+ * The list used to read every session's whole event log, three times, to
+ * draw one row each: on the owner's machine that is 118 sessions, 584 MB,
+ * 3.58M events, about 8.3 s before the picker appears. The sidecar the
+ * session already keeps (`<id>.meta.json`) is read in 2 ms for all 118. So
+ * the list reads the sidecar ONLY, and the sidecar carries what the row
+ * shows, as its own tenant beside the execution profile:
+ *
+ *   title, turns, last activity, state (open or the terminal's outcome),
+ *   uncertain executions, pending asks, whether the workspace is unknown,
+ *   and where the summary came from (a run, or the one-time migration).
+ *
+ * The runtime writes it at a run's start (state open — a run killed there
+ * reads "interrupted" in the list, which is the truth) and at its end. It
+ * is OBSERVATION: nothing in recovery, projection or a request reads it
+ * (the §6 purity rule), and a failed write never fails a run.
+ *
+ * `sessionSummary` is a pure function of the durable records, shared by the
+ * live writes and the one-time migration so the two can never disagree.
+ */
+import { existsSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { readProfile, readSummary, writeSummary } from "./profile.js";
+import { executionLedger } from "./ledger.js";
+import { openRunId } from "./recovery.js";
+import { sessionTitle } from "./store.js";
+/** Pending asks from the records alone: a permission request of the OPEN
+ *  run with no decision and no expiry — the session's own rule, restated
+ *  over records so the migration needs no live session. */
+function pendingAsks(records) {
+    const open = openRunId(records);
+    if (open === undefined)
+        return 0;
+    const decided = new Set();
+    const requested = new Set();
+    for (const r of records) {
+        const e = r.event;
+        if (e.type === "permission_requested" && r.runId === open && typeof e.decisionId === "string")
+            requested.add(e.decisionId);
+        else if ((e.type === "permission_decided" || e.type === "permission_expired") && typeof e.decisionId === "string")
+            decided.add(e.decisionId);
+    }
+    let n = 0;
+    for (const id of requested)
+        if (!decided.has(id))
+            n += 1;
+    return n;
+}
+/** The summary of a session's events — the core both writers share.
+ *  `open`, `updatedAt` and `asks` come from whoever knows them: a live
+ *  session knows its own run and its resolvers; the migration derives
+ *  them from the records. */
+export function summarizeEvents(events, opts) {
+    let state = opts.open ? "open" : null;
+    if (!opts.open) {
+        for (let i = events.length - 1; i >= 0; i -= 1) {
+            const e = events[i];
+            if (e.type === "terminal") {
+                state = e.outcome.kind;
+                break;
+            }
+        }
+    }
+    const title = sessionTitle(events.map((event) => ({ runId: "", ts: 0, event })));
+    return {
+        title: title === "(no prompt)" ? null : title,
+        turns: events.filter((e) => e.type === "user_input").length,
+        updatedAt: opts.updatedAt,
+        state,
+        uncertain: [...executionLedger(events).values()].filter((x) => x.status === "uncertain").length,
+        asks: opts.asks,
+        workspaceUnknown: opts.workspaceUnknown,
+        source: opts.source,
+    };
+}
+/** The summary of a session's durable RECORDS — the one-time migration's
+ *  input (a legacy log read exactly once, never through a live session). */
+export function sessionSummary(records, opts) {
+    return summarizeEvents(records.map((r) => r.event), {
+        open: openRunId(records) !== undefined,
+        updatedAt: records.at(-1)?.ts ?? opts.fallbackUpdatedAt ?? 0,
+        asks: pendingAsks(records),
+        workspaceUnknown: opts.workspaceUnknown,
+        source: opts.source,
+    });
+}
+// ── the list's read path, and the one-time migration ───────────────────
+/** The migration's marker: written once every legacy session has a
+ *  summary. From then on the list never reads a log (lead's ruling A): a
+ *  session still without a summary shows "no summary". */
+export const SUMMARY_MIGRATION_MARKER = ".summaries-migrated";
+/** Every session in `root`, from the DIRECTORY and the sidecars only — no
+ *  log is opened. The 0.40.0 dogfood's list path. */
+export function listSessionSidecars(root) {
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries.sort()) {
+        if (!entry.endsWith(".jsonl"))
+            continue;
+        const id = entry.slice(0, -".jsonl".length);
+        let mtime = 0;
+        try {
+            const st = statSync(join(root, entry));
+            if (st.size === 0)
+                continue; // an empty log is no session (the old list skipped it too)
+            mtime = st.mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        const profile = readProfile(root, id);
+        out.push({
+            id,
+            mtime,
+            summary: readSummary(root, id),
+            workspace: profile.kind === "ok" ? profile.profile.workspace : null,
+            profileName: profile.kind === "ok" ? profile.profile.profileName : null,
+        });
+    }
+    return out;
+}
+/** Whether the one-time migration still has work: the marker is absent. */
+export function summaryMigrationPending(root) {
+    return !existsSync(join(root, SUMMARY_MIGRATION_MARKER));
+}
+/**
+ * The ONE-TIME migration (lead's ruling A). Each session without a summary
+ * has its log read exactly once — through the store's plain loader, never a
+ * live session, so the profile contract cannot throw it — and its summary
+ * written with `source: "migration"`. A log that cannot be read gets what
+ * CAN be said (last activity from the file's mtime; title and turns
+ * unknown) and never throws the list. Resumable: each summary is written on
+ * its own, so a crash mid-way leaves the done ones done; the marker lands
+ * only when every session has one.
+ */
+export function migrateSummaries(root, load, onEach) {
+    const todo = listSessionSidecars(root).filter((s) => s.summary === null);
+    todo.forEach((s, i) => {
+        let summary;
+        try {
+            summary = sessionSummary(load(s.id), { workspaceUnknown: s.workspace === null, source: "migration", fallbackUpdatedAt: s.mtime });
+        }
+        catch {
+            summary = { title: null, turns: null, updatedAt: s.mtime, state: null, uncertain: 0, asks: 0, workspaceUnknown: s.workspace === null, source: "migration" };
+        }
+        try {
+            writeSummary(root, s.id, summary);
+        }
+        catch {
+            // a sidecar that cannot be written leaves this session without a
+            // summary; the list says so, and the marker still lands below
+        }
+        onEach?.(i + 1, todo.length);
+    });
+    writeFileSync(join(root, SUMMARY_MIGRATION_MARKER), `${new Date().toISOString()}\n`);
+    return todo.length;
+}

package/dist/session.d.ts

@@ -27,7 +27,7 @@
  * support in recovery.ts, the E1/E2 composition helpers in compose.ts —
  * same package, same exports (index.ts re-exports all four).
  */
-import { EventLog, type AbortSignalLike, type Adapter, type Event, type KisoExtension, type Message, type PermissionDecision, type Tool } from "@vincemakes/kiso-core";
+import { EventLog, type AbortSignalLike, type Adapter, type Event, type KisoExtension, type Message, type PermissionDecision, type Tool, type ToolSpec, type EventInput } from "@vincemakes/kiso-core";
 import { type TaskAssessment } from "./task-assessment.js";
 import { type ContinuationScope } from "@vincemakes/kiso-core";
 import { type ReasoningSetting } from "./provider/metadata.js";
@@ -93,10 +93,17 @@ export declare class AgentSession {
     #private;
     readonly id: string;
     readonly log: EventLog;
+    /** 0.40.0: what this open's drift acknowledgement replaced — the CLI
+     *  says so once. Null when the session opened without material drift. */
+    readonly driftAcknowledgement: import("./agent.js").DriftAcknowledgement | null;
+    /** 0.40.0: when the provider last billed this session (epoch ms) — the
+     *  record's time on load, the write's time after. A provider's prompt
+     *  cache expires with time, so an old bill means a cold prefix. */
+    get lastUsageAt(): number | undefined;
     /** Permanently invalidate the session after a rejected disk write (round 1). */
     poison(reason: string): void;
     ensureHealthy(): void;
-    constructor(id: string, log: EventLog, store: SessionStore, adapter: Adapter, config: SessionConfig);
+    constructor(id: string, log: EventLog, store: SessionStore, adapter: Adapter, config: SessionConfig, lastUsageAt?: number);
     /** Write-ahead through the store; a rejected write POISONS the session
      *  (round 1/round 4): the in-memory log no longer matches the disk — whatever
      *  the cause (stale handle, corruption, a live external writer, an I/O
@@ -107,6 +114,37 @@ export declare class AgentSession {
     endRun(run: Run): void;
     /** The conversation so far, as the model sees it. */
     projected(): readonly Message[];
+    /** 0.40.0: the context as the last bill measured it, plus what the log
+     *  appended since — or undefined when no bill describes it any more
+     *  (context-anchor.ts). `events` defaults to the session's log. */
+    contextAnchor(events?: readonly Event[]): number | undefined;
+    /** 0.40.0: what the context holds — the anchored figure, or the estimate
+     *  over the projection when no bill describes it. The thresholds and the
+     *  ctx row read this, never the bare estimate. */
+    contextUsed(): number;
+    /**
+     * ADR-0055 Amendment 1 (A1b) — the kernel's compaction point for ONE run,
+     * or undefined when nothing in-run is armed (the kernel then never asks).
+     *
+     * With `contextPolicy.tiers`: the §1a figure against the tiers — soft
+     * waits for a phase end (A3), hard and emergency fire now, an overflow
+     * fires once. The summary is in-band (A2) with ONE fallback to the
+     * serialised form; if both fail, an emergency or an overflow may prune
+     * once (A4b), and otherwise nothing happens and the run goes on.
+     *
+     * Without tiers, an EXPLICITLY configured `microcompact` keeps its old
+     * standing prune here, for SDK callers — the kernel no longer has one.
+     */
+    compactionPoint(run: {
+        readonly systemPrompt?: string;
+        readonly tools: () => readonly ToolSpec[];
+        readonly reasoning?: {
+            readonly thinking?: "adaptive" | "enabled" | "disabled";
+            readonly effort?: string;
+        };
+        readonly signal?: AbortSignalLike;
+        readonly maxRetries?: number;
+    }): ((events: readonly Event[], messages: readonly Message[], why: "request" | "overflow") => Promise<readonly EventInput[]>) | undefined;
     /**
      * merge round B (/model): replace the adapter for SUBSEQUENT runs. The
      * kernel reads the adapter through the loop-config closure at each
@@ -140,12 +178,18 @@ export declare class AgentSession {
         /** XP-1: the reasoning axes travel with the binding too; absent =
          *  fresh defaults (a new binding never inherits stale effort). */
         readonly reasoning?: ReasoningSetting;
+        /** 0.40.0: the config profile that named this binding; absent = none
+         *  (a direct provider/model, or an SDK caller) — recorded as null. */
+        readonly profileName?: string | null;
         /** CTX-1: the compaction threshold follows the live model's window.
          *  Absent KEEPS the current one — a caller that does not know the new
          *  model's window must not silently reset the policy to nothing. */
         readonly microcompact?: {
             readonly thresholdTokens: number;
         };
+        /** A1b: the new model's window, for the in-run tiers. Absent keeps the
+         *  current one, as `microcompact` does. */
+        readonly contextWindow?: number;
     }): void;
     /**
      * CTX-1: the compaction threshold alone, with NO profile revision.
@@ -164,6 +208,9 @@ export declare class AgentSession {
      * every open.
      */
     setMicrocompactThreshold(thresholdTokens: number): void;
+    /** A1b: the window the in-run tiers are drawn from, for a restored or
+     *  re-bound session (the CLI's one binding step calls both). */
+    setContextWindow(windowTokens: number): void;
     /** E2: the adapter identity (anthropic / openai-compat / openai-responses) — the route
      *  key the canonical consumer (CLI usage, the trace block) keys on. The
      *  per-run tracer reads the SAME live binding; one source, one
@@ -190,6 +237,15 @@ export declare class AgentSession {
     };
     /** XP-1: the selected reasoning axes (resolution happens per request). */
     get reasoning(): ReasoningSetting;
+    /**
+     * The 0.40.0 dogfood (item 2): the session list's row, written into the
+     * sidecar's `summary` tenant at a run's start (`open`) and at its end.
+     * Computed from the IN-MEMORY log — never a re-read of the file — and
+     * best-effort: a summary that cannot be written leaves the list saying
+     * less, and never fails the run. Observation only: nothing that decides
+     * recovery, projection or a request reads it.
+     */
+    recordSummary(open: boolean): void;
     /**
      * TUI2-R3v2 ③ — ONE model request that belongs to no run (the
      * safer-options seam, adjudicated 2026-08-18).
@@ -238,6 +294,7 @@ export declare class AgentSession {
     run(input: string | readonly import("@vincemakes/kiso-core").ContentBlock[], options?: {
         signal?: AbortSignalLike;
         source?: import("@vincemakes/kiso-core").MessageSource;
+        via?: import("@vincemakes/kiso-core").UserInputVia;
     }): Run;
     /**
      * Continue the interrupted run (Area 2): apply durable decisions,
@@ -265,6 +322,7 @@ export declare class AgentSession {
         drop?: boolean;
         focus?: string;
         manualBudget?: boolean;
+        onProgress?: (progress: import("./summarize.js").SummaryProgress) => void;
     }): Promise<SummarizeResult | null>;
     /**
      * E6 — the run-start context policy (candidate A + the crux drop arm).
@@ -404,6 +462,19 @@ export interface ContextPolicy {
         readonly keepResults?: number;
         readonly minTurns?: number;
     };
+    /**
+     * ADR-0055 Amendment 1 (A1b) — the IN-RUN tiers, drawn from the window:
+     * soft `min(0.5·w, 400K)` waits for a phase end, hard `min(0.8·w, 700K)`
+     * and emergency `w − reserve` fire at the next request, an overflow once.
+     * Present, the kernel asks before every request; the run-start summary
+     * and the standing microcompact above do not apply. `isCheck` is the
+     * phase detector's rule 1 (default: the runner table).
+     */
+    readonly tiers?: {
+        readonly windowTokens: number;
+        readonly isCheck?: (command: string) => boolean;
+        readonly maxFailures?: number;
+    };
 }
 export interface SessionConfig {
     readonly model: string;
@@ -423,6 +494,10 @@ export interface SessionConfig {
     readonly reasoning?: import("./provider/metadata.js").ReasoningSetting;
     /** XP-1 internal: a legacy session's deferred revision-1 write. */
     readonly profilePending?: true;
+    /** 0.40.0: the config profile name in force — recorded per revision. */
+    readonly profileName?: string;
+    /** 0.40.0: set when this open acknowledged material drift. */
+    readonly driftAcknowledgement?: import("./agent.js").DriftAcknowledgement;
     readonly systemPrompt?: string;
     readonly tools?: readonly Tool<any>[];
     readonly registry: import("@vincemakes/kiso-core").ToolRegistry;