@wrongstack/core 0.313.0 → 0.316.1

package/dist/types/session.d.ts

@@ -65,7 +65,28 @@ export interface SessionMetadata {
  * The only files that live inside the project tree are the committed
  * `.wrongstack/AGENTS.md` and `.wrongstack/skills/`.
  */
-export type SessionEvent = {
+export type SessionEvent = SessionEventVariant & SessionEventAttribution;
+/**
+ * Attribution stamped onto a journal event by the WRITER, never by the
+ * producer that built it.
+ *
+ * A leader's JSONL can carry events produced by its subagents: the
+ * parent-interleaved writer (`createParentSubagentSessionWriter`) forwards a
+ * subagent's appends into the leader's journal because that subagent has no
+ * journal of its own. Without a stamp those appends are indistinguishable
+ * from the leader's, so a transcript reader cannot say which agent ran which
+ * tool. `withAgentAttribution` sets this at the writer boundary — the one
+ * place that knows whose writer it is — so no emit site has to remember.
+ *
+ * Absent means "the session's own leader". Old journals have no stamp at all,
+ * which reads the same way and is correct: they predate subagent interleaving
+ * being attributable.
+ */
+export interface SessionEventAttribution {
+    /** Subagent that produced this event; absent = the session's leader. */
+    agentId?: string | undefined;
+}
+type SessionEventVariant = {
     type: 'session_start';
     ts: string;
     id: string;
@@ -105,6 +126,21 @@ export type SessionEvent = {
     content: ContentBlock[];
     stopReason: string;
     usage: Usage;
+    /**
+     * Model that produced this response and billed this `usage`.
+     *
+     * Optional because logs written before this field existed omit it —
+     * never because a live writer may skip it. `usage` is the only place
+     * token counts are journaled, so without these two fields the journal
+     * cannot answer "which model burned these tokens": `session_start`
+     * records only the model the session OPENED with (a mid-session switch
+     * or a fallback rotation leaves it stale), and `llm_request` carries
+     * `model` but no provider. Readers must still tolerate `undefined` and
+     * fall back to the nearest preceding `llm_request` / `session_start`.
+     */
+    model?: string | undefined;
+    /** Provider id that served this response. See {@link model}. */
+    provider?: string | undefined;
 } | {
     type: 'tool_use';
     ts: string;
@@ -250,26 +286,121 @@ export type SessionEvent = {
     ts: string;
     agentId: string;
     role: string;
+} | {
+    /**
+     * Binds a spawned agent to the transcript it writes into.
+     *
+     * Separate from `agent_spawned` because the two facts are learned in
+     * different places: the fleet layer emits `agent_spawned` once the
+     * coordinator hands back an id, while the writer is built one layer
+     * down in the subagent factory, which has no channel back to that emit
+     * site. Threading one would have changed five signatures for a fact
+     * that is naturally its own record — and would still be optional on
+     * `agent_spawned`, since an agent running on the parent-interleaved
+     * writer never gets a transcript of its own and emits no link at all.
+     *
+     * Readers join on `agentId` within the session.
+     */
+    type: 'agent_session_linked';
+    ts: string;
+    agentId: string;
+    /** The subagent journal's own session id. */
+    agentSessionId: string;
+    /**
+     * Absolute path of the subagent's JSONL at the time it was opened.
+     * Absent for in-memory writers (tests, ephemeral runs), which have a
+     * session id but no file.
+     */
+    transcriptPath?: string | undefined;
+    provider?: string | undefined;
+    model?: string | undefined;
+    /** Set when this agent was spawned by another agent, not the leader. */
+    parentAgentId?: string | undefined;
 } | {
     type: 'agent_stopped';
     ts: string;
     agentId: string;
+    /** Why the agent ended. Absent in journals written before this field. */
+    reason?: 'completed' | 'aborted' | 'failed' | 'evicted' | undefined;
+    /** This agent's own cumulative spend, when the stopper knows it. */
+    usage?: Usage | undefined;
 } | {
     type: 'agent_error';
     ts: string;
     agentId: string;
     error: string;
 } | {
-    type: 'spec_parsed';
+    /**
+     * A `delegate` tool call handing work to a subagent.
+     *
+     * Distinct from `agent_spawned`, which records that an agent exists.
+     * This records that the LEADER stopped and waited on it, which is the
+     * thing the transcript shows: every surface renders a delegation line
+     * live (the TUI even suppresses the generic tool card in its favour),
+     * and none of it reached disk — so a resumed session showed a gap where
+     * minutes of delegated work had happened.
+     */
+    type: 'delegate_started';
+    ts: string;
+    /** Resolved roster role or free-form subagent name. */
+    target: string;
+    /** The instruction handed to the subagent. */
+    task: string;
+    subagentId?: string | undefined;
+} | {
+    type: 'delegate_completed';
+    ts: string;
+    target: string;
+    task: string;
+    ok: boolean;
+    /** `success` | `timeout` | `host_timeout` | `stopped` | … */
+    status?: string | undefined;
+    /** One-line human summary, as the live surfaces render it. */
+    summary: string;
+    durationMs: number;
+    iterations: number;
+    toolCalls: number;
+    costUsd?: number | undefined;
+    subagentId?: string | undefined;
+} | {
+    /**
+     * The loop detector acted on a repeating run.
+     *
+     * Only `action: 'cut'` is worth a record: a `steer` is an in-band nudge
+     * the model absorbs, while a cut ENDS the turn — and without this the
+     * run came back as a bare `max_iterations` with nothing saying why.
+     */
+    type: 'loop_detected';
     ts: string;
-    specId: string;
-    title: string;
-    completeness: number;
+    /** Comma-separated tool names, or empty for a pure message loop. */
+    tools: string;
+    repeatCount: number;
+    iteration: number;
+    kind?: 'tool' | 'message' | 'mixed' | undefined;
+    action?: 'steer' | 'cut' | undefined;
 } | {
-    type: 'spec_analyzed';
+    /**
+     * The active provider/model changed mid-session.
+     *
+     * `reason: 'fallback'` is the automatic switch after a provider failure;
+     * `'user'` is an explicit `/model` or UI change. Either way the rest of
+     * the transcript was produced by a different model than the one
+     * `session_start` names, and a reader with no record of the switch
+     * attributes it all to the first one.
+     */
+    type: 'model_switched';
     ts: string;
-    specId: string;
-    gaps: string[];
+    from?: {
+        providerId: string;
+        model: string;
+    } | undefined;
+    to: {
+        providerId: string;
+        model: string;
+    };
+    reason: 'fallback' | 'user';
+    /** HTTP status that triggered an automatic fallback, when there was one. */
+    status?: number | undefined;
 } | {
     type: 'skill_activated';
     ts: string;
@@ -530,7 +661,11 @@ export interface SessionData {
      * in flight (crash/interrupt). Computed during replay BEFORE adjacency
      * repair strips them. `resume()` surfaces this as an informational notice so
      * the user/model know work was interrupted; the tools are NOT re-executed.
-     * Undefined for events-only loads (no message reconstruction).
+     *
+     * Only present when at least one call was left open: **absent means none**,
+     * never zero (see `load-session-data.ts`). It is also absent for
+     * events-only loads, which reconstruct no messages to count. Read it as
+     * `data.pendingToolUseCount ?? 0` rather than testing for `undefined`.
      */
     pendingToolUseCount?: number | undefined;
     /**
@@ -561,9 +696,28 @@ export interface ForkedSession {
     /** Available for checkpoint forks captured by workspace-CAS-aware writers. */
     workspaceCheckpoint?: WorkspaceCheckpointRef | undefined;
 }
+/**
+ * Byte-level progress for a session JSONL load. `loadedBytes` counts raw
+ * source bytes consumed so far (newline-inclusive approximation) and
+ * `totalBytes` is the source file size at load start.
+ */
+export interface SessionLoadProgress {
+    loadedBytes: number;
+    totalBytes: number;
+}
 export interface SessionStore {
     create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
-    load(id: string): Promise<SessionData>;
+    /**
+     * Read a session without claiming it for writing.
+     *
+     * `onLoadProgress` mirrors {@link SessionStore.resume} — the implementation
+     * has always accepted it, but the interface did not declare it, so the only
+     * caller that can stream progress for a read-only view (a resume falling
+     * back to showing the transcript it could not attach to) had to drop it and
+     * leave the user staring at a frozen screen for the length of a 131 MB
+     * parse. Implementations may ignore it.
+     */
+    load(id: string, onLoadProgress?: (progress: SessionLoadProgress) => void): Promise<SessionData>;
     /**
      * Open an existing session for append, returning both a writer that
      * continues writing to the same JSONL file and the replayed state
@@ -571,8 +725,12 @@ export interface SessionStore {
      * `session_resumed` marker is appended for audit. New writers may also
      * persist the exact conversation journal (`message_*` events); legacy logs
      * containing only user/assistant/tool events remain replayable.
+     *
+     * Optional `onLoadProgress` streams byte-level parse progress for large
+     * journals so callers can surface a live indicator; implementations may
+     * ignore it, and a warm load cache reports a single completed event.
      */
-    resume(id: string): Promise<ResumedSession>;
+    resume(id: string, onLoadProgress?: (progress: SessionLoadProgress) => void): Promise<ResumedSession>;
     /**
      * Create a non-destructive child journal from a persisted parent boundary.
      * Parent file snapshots are intentionally not inherited as rewind authority;
@@ -654,6 +812,8 @@ export interface SessionStore {
 }
 export interface SessionWriter {
     readonly id: string;
+    /** Original session start timestamp, used by resumed surfaces to keep uptime stable. */
+    readonly startedAt?: string | undefined;
     /**
      * Session-level trace ID for correlating storage events with agent
      * iterations in observability pipelines. Generated once at Context
@@ -823,4 +983,5 @@ export interface SessionWriter {
      */
     clearInFlightMarker(reason: 'clean' | 'aborted' | 'recovered'): Promise<void>;
 }
+export {};
 //# sourceMappingURL=session.d.ts.map

package/dist/types/system-prompt.d.ts

@@ -1,3 +1,4 @@
+import type { SystemInstructionVariant } from '../core/instruction-bundle.js';
 import type { MailboxAgentStatus } from '../coordination/mailbox-types.js';
 import type { TextBlock } from './blocks.js';
 import type { Tool } from './tool.js';
@@ -32,6 +33,32 @@ export interface BuildContext {
      * linked Git worktrees in the same canonical project.
      */
     onlineAgents?: MailboxAgentStatus[] | undefined;
+    /**
+     * Identity variant for THIS build — `system.md`, `system-lite.md` or
+     * `system-pro.md`.
+     *
+     * The builder is one process-wide instance and used to take the variant once,
+     * at construction, from the boot config. With four conversations on one
+     * process that made the identity a property of the process: picking a lighter
+     * identity in one tab was either discarded on that tab's next turn (the
+     * pre-run prompt refresh rebuilt it from the boot variant) or applied to all
+     * of them. Passing it per build makes it a property of the conversation,
+     * which is what it always described.
+     *
+     * Omitted keeps the builder's configured default.
+     */
+    systemVariant?: SystemInstructionVariant | undefined;
+    /**
+     * Autonomy mode of THIS conversation.
+     *
+     * The ETERNAL AUTONOMY block is injected from a process-wide mode ref, which
+     * one tab could move for all of them — so switching a background tab to
+     * eternal put those instructions into every other conversation's prompt.
+     * Passing it per build makes the block follow the conversation that is
+     * actually in that mode. Omitted keeps the host's process-wide answer, which
+     * is the only one a CLI or TUI has.
+     */
+    autonomy?: string | undefined;
 }
 /**
  * Stability regions for the system prompt.

package/dist/utils/config-backup.d.ts

@@ -2,7 +2,7 @@
  * Minimal paths object needed for config backup — just the global root
  * from which we derive the backup history directory.
  */
-export interface ConfigBackupPaths {
+interface ConfigBackupPaths {
     globalRoot: string;
 }
 /**
@@ -11,10 +11,18 @@ export interface ConfigBackupPaths {
  * recover from accidental changes. Backups are never cleaned up automatically.
  */
 export declare function configHistoryDir(globalRoot: string): string;
+/**
+ * Derive a human-readable slug for a config file path relative to the
+ * ~/.wrongstack root. Examples:
+ *   config.json                            →  config
+ *   profiles/default/config.json           →  profiles-default-config
+ */
+export declare function configSlug(absolutePath: string, globalRoot: string): string;
 /**
  * Before overwriting a config file, save its current content to the
  * config-history directory with a timestamp. Best-effort: failures are
  * silently ignored so they never block the config write itself.
  */
 export declare function backupConfigFile(filePath: string, paths: ConfigBackupPaths): Promise<void>;
+export {};
 //# sourceMappingURL=config-backup.d.ts.map

package/dist/utils/error.js

@@ -1,7 +1,6 @@
-// src/utils/error.ts
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
+import {
+  toErrorMessage
+} from "../chunk-TBRL2RCC.js";
 export {
   toErrorMessage
 };

package/dist/utils/expect-defined.js

@@ -1,12 +1,6 @@
-// src/utils/expect-defined.ts
-function expectDefined(value, label) {
-  if (value === null || value === void 0) {
-    const err = new Error(label ? `Expected ${label} to be defined` : "Expected value to be defined");
-    err.name = "ExpectDefinedError";
-    throw err;
-  }
-  return value;
-}
+import {
+  expectDefined
+} from "../chunk-PFZO3C6H.js";
 export {
   expectDefined
 };