@vincemakes/kiso-code 0.39.2 → 0.40.1

package/dist/replay.js

@@ -0,0 +1,158 @@
+/**
+ * 4c — a resumed session's history, replayed into cells.
+ *
+ * REL-0152-D5's tail printed the last two turns as text lines — a raw
+ * block, not cells — so nothing earlier could be read, and a fold line
+ * naming a key would have promised a read the product could not deliver.
+ * This drives the Body's own mutations over the durable events — the same
+ * calls a live run makes — so the turns render through the committed-cell
+ * renderer, route B's reprint prints them again on a resize, and the
+ * earlier turns sit in ONE fold row the ctrl+r viewer reads.
+ *
+ * Still a projection: it reads the log the session already loaded, writes
+ * nothing durable, and holds no state of its own.
+ *
+ * The shape (owner-ruled, option A):
+ *   - the last two turns in full;
+ *   - every earlier turn in one fold row, "N earlier turns · ctrl+r to read";
+ *   - with a compaction, the latest checkpoint in place of the fold — its
+ *     summary (what the model sees next) and the turns it covers, read in
+ *     the viewer — then any uncovered earlier turns folded as above.
+ */
+import { echoText } from "@vincemakes/kiso-tui-cells/render";
+/** How many turns stay on screen in full. */
+const FULL_TURNS = 2;
+/** A user turn's opening line, or null when this input does not open one
+ *  (a system-sourced input is machinery inside a turn; an empty ask is
+ *  nothing). The words are the chip's words: a skill turn is the line the
+ *  person typed, an image turn keeps its mark. */
+function askOf(e) {
+    if (e.type !== "user_input" || e.source === "system")
+        return null;
+    const via = e.via;
+    const text = typeof via?.line === "string" ? via.line : echoText(e.content);
+    return text.trim() === "" ? null : text;
+}
+/** Split events into turns: each starts at a user turn's input; anything
+ *  before the first one belongs to no turn and is dropped. */
+export function turnsOf(events) {
+    const turns = [];
+    for (const e of events) {
+        if (askOf(e) !== null)
+            turns.push([e]);
+        else if (turns.length > 0)
+            turns[turns.length - 1].push(e);
+    }
+    return turns;
+}
+/** One turn through the Body — consumeRun's mapping, minus everything that
+ *  needs the live process (clocks, tailers, usage, the recap). */
+function replayTurn(body, turn) {
+    let thinking = false;
+    let said = false;
+    const results = new Set();
+    for (const e of turn) {
+        if (thinking && e.type !== "thinking") {
+            body.thinkingEnd();
+            thinking = false;
+        }
+        switch (e.type) {
+            case "user_input": {
+                const ask = askOf(e);
+                if (ask !== null)
+                    body.userLine(ask);
+                else if (e.source === "system") {
+                    body.notice("verification pass");
+                    body.notice(`  ${typeof e.content === "string" ? e.content : ""}`);
+                }
+                break;
+            }
+            case "thinking":
+                if (typeof e.text === "string") {
+                    body.thinkingAppend(e.text);
+                    thinking = true;
+                }
+                break;
+            case "tool_call_end":
+                body.toolStart(String(e.name), String(e.callId), e.input ?? {});
+                said = true;
+                break;
+            case "tool_result": {
+                const text = typeof e.content === "string" ? e.content : "";
+                let reason = null;
+                if ((e.tags ?? []).includes("denied")) {
+                    const m = /^\[Permission denied\] (.*)$/.exec(text);
+                    if (m !== null)
+                        reason = m[1];
+                }
+                body.toolResult(String(e.callId), { content: text, isError: e.isError === true, reason, untimed: true });
+                results.add(String(e.callId));
+                break;
+            }
+            case "text_delta":
+                if (typeof e.text === "string") {
+                    body.textAppend(e.text);
+                    if (e.text.trim() !== "")
+                        said = true;
+                }
+                break;
+            case "text_end":
+                body.textEnd();
+                break;
+            case "model_output_abandoned":
+                body.textEnd();
+                body.notice("stream interrupted — the draft above is abandoned");
+                break;
+            default:
+                break;
+        }
+    }
+    if (thinking)
+        body.thinkingEnd();
+    body.textEnd();
+    // A turn with nothing recorded after the ask is the turn that was
+    // INTERRUPTED — the case resume exists for; saying so beats a blank.
+    if (!said)
+        body.notice("no reply recorded — this is where it stopped");
+    body.endTurn(0);
+}
+const plural = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
+/**
+ * Replay a session's durable events into the body. Returns the number of
+ * turns it found (0: a fresh session — nothing is drawn).
+ */
+export function replayInto(body, events, W = 80) {
+    // The latest checkpoint: the turns it covers are what the model will
+    // read as its summary, not as turns.
+    let checkpoint = null;
+    for (const e of events) {
+        if (e.type === "summarized" && typeof e.coversToSeq === "number" && typeof e.summary === "string")
+            checkpoint = { coversToSeq: e.coversToSeq, summary: e.summary };
+    }
+    const covered = checkpoint === null ? [] : turnsOf(events.filter((e) => typeof e.seq === "number" && e.seq <= checkpoint.coversToSeq));
+    const rest = turnsOf(checkpoint === null ? events : events.filter((e) => typeof e.seq !== "number" || e.seq > checkpoint.coversToSeq));
+    const total = covered.length + rest.length;
+    if (total === 0)
+        return 0;
+    const shown = rest.slice(-FULL_TURNS);
+    const earlier = rest.slice(0, rest.length - shown.length);
+    const label = total > shown.length ? `resuming · ${plural(total, "turn")}, showing the last ${shown.length}` : `resuming · ${plural(total, "turn")}`;
+    const head = `─── ${label} `;
+    body.raw([`${head}${"─".repeat(Math.max(1, W - head.length))}`.slice(0, Math.max(1, W))]);
+    if (checkpoint !== null) {
+        const summary = checkpoint.summary;
+        body.fold(`checkpoint · summarizes ${plural(covered.length, "earlier turn")} · ctrl+r to read`, () => {
+            for (const t of covered)
+                replayTurn(body, t);
+        }, summary);
+    }
+    if (earlier.length > 0) {
+        body.fold(`${plural(earlier.length, "earlier turn")} · ctrl+r to read`, () => {
+            for (const t of earlier)
+                replayTurn(body, t);
+        });
+    }
+    for (const t of shown)
+        replayTurn(body, t);
+    return total;
+}

package/dist/resume-tail.js

@@ -47,7 +47,10 @@ export function resumeTail(events, W = 80) {
             // RUNTIME keeps its own `contentText` (R7) because it cannot
             // depend on tui-cells — two implementations, one per direction,
             // agreeing on "(image)".
-            const text = echoText(e.content).trim();
+            // 0.40.0: a skill turn is shown as the line the person typed —
+            // its content is a SKILL.md body they never wrote.
+            const via = e.via;
+            const text = (typeof via?.line === "string" ? via.line : echoText(e.content)).trim();
             if (text === "")
                 continue;
             if (ask !== null)

package/dist/resume.js

@@ -4,7 +4,7 @@
  */
 import { idleStatus, runningStatus } from "@vincemakes/kiso-tui";
 import { getMode } from "./mode.js";
-import { agentModel, dock } from "./state.js";
+import { agentModel, dock, retryOnRow, floorOn } from "./state.js";
 import { pendingAsk, resolveUncertains } from "./trust-ui.js";
 import { failOnFauxExhaustion } from "./faux-glue.js";
 import { consumeRun, estimateCtxRatio, startStatusSpinner } from "./chat.js";
@@ -28,7 +28,7 @@ export async function resume(session, prompt, faux, input) {
     const statusCb = (u, ctx) => {
         runUsage = u;
         if (dock.active)
-            dock.setStatus(runningStatus(runGlyph, runStart, u.out, ctx));
+            dock.setStatus(runningStatus(runGlyph, runStart, u.out, ctx, null, process.stdout.columns > 0 ? process.stdout.columns : 80, retryOnRow()));
     };
     // the recovery flow prints the BARE mode (chat spells plan's posture) —
     // the extraction keeps that difference, it was not asked to settle it.
@@ -37,7 +37,7 @@ export async function resume(session, prompt, faux, input) {
         // same budget. It has no meter, so nothing here can be dropped that
         // was not already at risk of being cut.
         if (dock.active)
-            dock.setStatus(idleStatus(getMode(), agentModel, estimateCtxRatio(session), undefined, process.stdout.columns > 0 ? process.stdout.columns : 80));
+            dock.setStatus(idleStatus(getMode(), agentModel, estimateCtxRatio(session), undefined, process.stdout.columns > 0 ? process.stdout.columns : 80, !floorOn));
     };
     const withRun = async (run) => {
         currentRun = run;

package/dist/retries.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ADR-0005 Amendment 2: KISO_MAX_RETRIES overrides the kernel's default
+ * budget, CLAMPED to 15 — a typo must not turn one failing request into an
+ * hour of retries at 32 s apiece. The kernel reads no environment; this is
+ * the front door's knob, passed in as `maxRetries`. Absent or unreadable
+ * means the kernel's own default.
+ */
+export declare const MAX_RETRIES_CLAMP = 15;
+export declare function maxRetriesFromEnv(raw?: string | undefined): number | undefined;

package/dist/retries.js

@@ -0,0 +1,16 @@
+/**
+ * ADR-0005 Amendment 2: KISO_MAX_RETRIES overrides the kernel's default
+ * budget, CLAMPED to 15 — a typo must not turn one failing request into an
+ * hour of retries at 32 s apiece. The kernel reads no environment; this is
+ * the front door's knob, passed in as `maxRetries`. Absent or unreadable
+ * means the kernel's own default.
+ */
+export const MAX_RETRIES_CLAMP = 15;
+export function maxRetriesFromEnv(raw = process.env.KISO_MAX_RETRIES) {
+    if (raw === undefined || raw.trim() === "")
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 0)
+        return undefined;
+    return Math.min(n, MAX_RETRIES_CLAMP);
+}

package/dist/session-cards.d.ts

@@ -28,9 +28,9 @@
  * terminal layer (sessionNote — the KC3 §1 split); this file owns the
  * FACTS.
  */
-import { type StoreRecord } from "@vincemakes/kiso-runtime/internal";
+import { type SessionListing, type StoreRecord } from "@vincemakes/kiso-runtime/internal";
 /** The five durable states, in the order the projection resolves them. */
-export type SessionBadge = "uncertain" | "ask" | "interrupted" | "completed" | "failed";
+export type SessionBadge = "uncertain" | "ask" | "interrupted" | "completed" | "failed" | "unknown";
 export interface SessionCard {
     readonly id: string;
     /** REL-0152-D6b: what the conversation was ABOUT. An id is unique and
@@ -43,7 +43,7 @@ export interface SessionCard {
      *  counts runIds, which a resume increments without the human having
      *  said anything — that is a different number and not the one a
      *  picker row means.) */
-    readonly turns: number;
+    readonly turns: number | null;
     /** The last record's own stamp — the store's `updatedAt`, never a
      *  file mtime (a copied home would lie about every age). */
     readonly updatedAt: number;
@@ -55,6 +55,14 @@ export interface SessionCard {
      *  open. The ✗ note names it rather than inventing one word for six
      *  different endings. */
     readonly outcome: string | null;
+    /** 0.40.0: where the session started (its profile's `workspace`);
+     *  null when unknown. */
+    readonly workspace: string | null;
+    /** 0.40.0: the config profile its latest revision names. */
+    readonly profileName: string | null;
+    /** 0.40.0: in a project folder by the migration's inference, never by
+     *  a recorded workspace — the listing marks it. */
+    readonly inferred?: boolean;
 }
 /**
  * The projection. `asks` arrives as DATA because its accessor lives on
@@ -78,6 +86,8 @@ export declare function projectSessionCard(input: {
     readonly updatedAt: number;
     readonly records: readonly StoreRecord[];
     readonly asks: number;
+    readonly workspace?: string | null;
+    readonly profileName?: string | null;
 }): SessionCard;
 /** The shapes this module needs from the agent — structural, so the
  *  projection is testable without standing up a provider. */
@@ -101,5 +111,24 @@ interface CardSource {
  * loads its records and builds an event log, and writes nothing (no
  * lock, no file creation) — the read-only listing rule holds.
  */
-export declare function collectSessionCards(agent: CardSource, load: (id: string) => readonly StoreRecord[]): Promise<SessionCard[]>;
+export declare function collectSessionCards(agent: CardSource, load: (id: string) => readonly StoreRecord[], profileOf?: (id: string) => {
+    readonly workspace: string | null;
+    readonly profileName: string | null;
+}): Promise<SessionCard[]>;
+/**
+ * The 0.40.0 dogfood (item 2) — a card from the SIDECAR alone: the summary
+ * tenant the runtime writes at each run's start and end (or the one-time
+ * migration wrote), plus the profile's workspace and name. No log is read.
+ * A session with no summary says so ("no summary"); one whose log could not
+ * be read when it was summarised says that ("log unreadable") — never a
+ * guess, and never a read of the log to find out.
+ */
+export declare function cardFromListing(l: SessionListing & {
+    readonly inferred?: boolean;
+}): SessionCard;
+/** Every card from the sidecars, newest first (the order the picker and
+ *  `kiso sessions` both want). */
+export declare function cardsFromListings(listings: readonly (SessionListing & {
+    readonly inferred?: boolean;
+})[]): SessionCard[];
 export {};

package/dist/session-cards.js

@@ -74,7 +74,18 @@ export function projectSessionCard(input) {
                     : outcome === "completed"
                         ? "completed"
                         : "failed";
-    return { id: input.id, title: sessionTitle(input.records), badge, turns, updatedAt: input.updatedAt, uncertain, asks: input.asks, outcome };
+    return {
+        id: input.id,
+        title: sessionTitle(input.records),
+        badge,
+        turns,
+        updatedAt: input.updatedAt,
+        uncertain,
+        asks: input.asks,
+        outcome,
+        workspace: input.workspace ?? null,
+        profileName: input.profileName ?? null,
+    };
 }
 /**
  * The listing's cards, newest first — the order both the picker and
@@ -85,7 +96,7 @@ export function projectSessionCard(input) {
  * loads its records and builds an event log, and writes nothing (no
  * lock, no file creation) — the read-only listing rule holds.
  */
-export async function collectSessionCards(agent, load) {
+export async function collectSessionCards(agent, load, profileOf = () => ({ workspace: null, profileName: null })) {
     const cards = [];
     for (const meta of [...agent.sessions()].sort((a, b) => b.updatedAt - a.updatedAt)) {
         // XP-1: the LISTING never enforces the profile contract — a session
@@ -101,7 +112,37 @@ export async function collectSessionCards(agent, load) {
         catch {
             // blocked by the profile contract — the card carries no ask badge
         }
-        cards.push(projectSessionCard({ id: meta.id, updatedAt: meta.updatedAt, records: load(meta.id), asks }));
+        cards.push(projectSessionCard({ id: meta.id, updatedAt: meta.updatedAt, records: load(meta.id), asks, ...profileOf(meta.id) }));
     }
     return cards;
 }
+/**
+ * The 0.40.0 dogfood (item 2) — a card from the SIDECAR alone: the summary
+ * tenant the runtime writes at each run's start and end (or the one-time
+ * migration wrote), plus the profile's workspace and name. No log is read.
+ * A session with no summary says so ("no summary"); one whose log could not
+ * be read when it was summarised says that ("log unreadable") — never a
+ * guess, and never a read of the log to find out.
+ */
+export function cardFromListing(l) {
+    const s = l.summary;
+    const base = { id: l.id, workspace: l.workspace, profileName: l.profileName, ...(l.inferred === true ? { inferred: true } : {}) };
+    if (s === null)
+        return { ...base, title: l.id, badge: "unknown", turns: null, updatedAt: l.mtime, uncertain: 0, asks: 0, outcome: "no summary" };
+    const badge = s.uncertain > 0 ? "uncertain" : s.asks > 0 ? "ask" : s.state === "open" ? "interrupted" : s.state === "completed" ? "completed" : s.state === null ? "unknown" : "failed";
+    return {
+        ...base,
+        title: s.title ?? l.id,
+        badge,
+        turns: s.turns,
+        updatedAt: s.updatedAt,
+        uncertain: s.uncertain,
+        asks: s.asks,
+        outcome: badge === "unknown" ? (s.turns === null ? "log unreadable" : "no run recorded") : s.state === "open" ? null : s.state,
+    };
+}
+/** Every card from the sidecars, newest first (the order the picker and
+ *  `kiso sessions` both want). */
+export function cardsFromListings(listings) {
+    return listings.map(cardFromListing).sort((a, b) => b.updatedAt - a.updatedAt);
+}

package/dist/session-migration.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 0.40.0 — the one-time move of the legacy `KISO_HOME/sessions` into the
+ * per-project folders (see projects.ts). The lead's conditions, in order:
+ *
+ *   1. the manifest is written FIRST: every session's old folder, new
+ *      folder, reason and evidence, before any file moves;
+ *   2. a session whose lock a live process holds is skipped, and moved on a
+ *      later start;
+ *   3. a recorded workspace places a session; otherwise the paths its tools
+ *      touched, mapped to their repository on disk, place it when one root
+ *      has at least 3 mentions and 80% of them; anything else goes to
+ *      `_unknown`. A delegated child follows its parent;
+ *   4. the move is announced once, naming the reverse command.
+ *
+ * Each session moves trace → sidecar → lock → log (projects.ts), so a crash
+ * leaves the log in the legacy folder, where the next start finds it again.
+ * Nothing is deleted: files the move does not own (orphan sidecars, the
+ * delegation artifacts, whose paths the parents' logs record) stay where
+ * they are.
+ */
+export type PlacementReason = "recorded" | "inferred" | "unknown" | "skipped-live";
+export interface Placement {
+    readonly id: string;
+    readonly reason: PlacementReason;
+    /** the project the session goes to; null → `_unknown` (or, when
+     *  skipped, nowhere yet) */
+    readonly workspace: string | null;
+    readonly from: string;
+    readonly to: string | null;
+    /** for `inferred`, and for the near misses that went to `_unknown` */
+    readonly evidence?: {
+        readonly root: string;
+        readonly mentions: number;
+        readonly total: number;
+    };
+    /** a delegated child follows this session */
+    readonly parent?: string;
+}
+/** The inference's two thresholds (the lead's ruling). */
+export declare const INFER_MIN_MENTIONS = 3;
+export declare const INFER_MIN_SHARE = 0.8;
+/** The legacy sessions still to move: non-empty logs, sorted. */
+export declare function pendingLegacyIds(home: string): string[];
+/**
+ * The repository a path belongs to: the nearest ancestor holding `.git`.
+ * A linked worktree (`.git` is a file naming `<repo>/.git/worktrees/x`)
+ * belongs to its main repository. Walks stop at the home directory, and
+ * paths inside KISO_HOME belong to no project.
+ */
+export declare function repoRootOf(path: string, cache: Map<string, string | null>, stops: {
+    readonly home: string;
+    readonly kisoHome: string;
+}): string | null;
+/** The absolute paths one log's tool calls and tool results name. */
+export declare function toolPaths(logText: string): string[];
+/** The inference over one log: the dominant repository and its counts. */
+export declare function inferWorkspace(logText: string, cache: Map<string, string | null>, stops: {
+    readonly home: string;
+    readonly kisoHome: string;
+}): {
+    readonly root: string;
+    readonly mentions: number;
+    readonly total: number;
+    readonly placed: boolean;
+} | null;
+/**
+ * The plan: where every pending legacy session goes, and why. A pure read
+ * of the legacy folder and the repositories on disk — nothing is written,
+ * so the owner's dry run is this function over a copy.
+ */
+export declare function planMigration(home: string, opts?: {
+    readonly userHome?: string;
+}): Placement[];
+export interface MigrationCounts {
+    readonly recorded: number;
+    readonly inferred: number;
+    readonly unknown: number;
+    readonly skippedLive: number;
+}
+export declare function countPlan(plan: readonly Placement[]): MigrationCounts;
+export interface MigrationResult {
+    readonly manifest: string;
+    readonly counts: MigrationCounts;
+    readonly moved: number;
+}
+/**
+ * Run the plan. The manifest lands before the first move; after the moves
+ * it is rewritten with each entry's outcome. Returns null when there was
+ * nothing to move (all skipped, or nothing pending).
+ */
+export declare function runMigration(home: string, plan: readonly Placement[], now?: Date): MigrationResult | null;
+/** The announcement, once per migration that moved something. */
+export declare function migrationNotice(result: MigrationResult): string;
+/**
+ * `kiso sessions --reverse-migration <manifest>`: every entry the manifest
+ * moved goes back to the legacy folder, the log FIRST (so a crash leaves it
+ * listed from its old place), and the marker switches the per-project
+ * layout off. Sessions created in project folders after the migration are
+ * not in the manifest and stay; the count says so.
+ */
+export declare function reverseMigration(home: string, manifestPath: string): {
+    readonly restored: number;
+    readonly left: number;
+};