pikiloom 0.4.71 → 0.4.73

package/packages/kernel/dist/ports/defaults.d.ts

@@ -32,6 +32,7 @@ export declare class FsSessionStore implements SessionStore {
     reconcileRunning(isAlive: (pid: number) => boolean): Promise<number>;
     appendTurn(agent: string, sessionId: string, turn: UniversalSnapshot): Promise<void>;
     history(agent: string, sessionId: string): Promise<UniversalSnapshot[]>;
+    truncateTurns(agent: string, sessionId: string, throughTaskId: string | null): Promise<void>;
 }
 /**
  * Is a pid currently a live process? `signal 0` probes without delivering a signal: ESRCH =>

package/packages/kernel/dist/ports/defaults.js

@@ -145,6 +145,26 @@ export class FsSessionStore {
         }
         return out;
     }
+    // Rewrite turns.jsonl to the prefix through `throughTaskId` inclusive (in-place rewind). null
+    // clears the transcript; an unknown id keeps everything (no-op) so a stale cut can't wipe
+    // history. Atomic (temp file + rename) so a crash can't leave a half-written store.
+    async truncateTurns(agent, sessionId, throughTaskId) {
+        const all = await this.history(agent, sessionId);
+        let kept;
+        if (throughTaskId == null)
+            kept = [];
+        else {
+            const cut = all.findIndex((t) => t.taskId === throughTaskId);
+            if (cut < 0)
+                return; // unknown cut — leave the transcript untouched
+            kept = all.slice(0, cut + 1);
+        }
+        const p = this.turnsPath(agent, sessionId);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        const tmp = `${p}.tmp-${process.pid}`;
+        fs.writeFileSync(tmp, kept.map((t) => JSON.stringify(t)).join('\n') + (kept.length ? '\n' : ''));
+        fs.renameSync(tmp, p);
+    }
 }
 /**
  * Is a pid currently a live process? `signal 0` probes without delivering a signal: ESRCH =>

package/packages/kernel/dist/protocol/index.d.ts

@@ -86,6 +86,14 @@ export interface UniversalSnapshot {
     toolCalls?: UniversalToolCall[];
     subAgents?: UniversalSubAgent[];
     usage?: UniversalUsage | null;
+    /** Set when the CLI compacted the context mid-turn (its `compact_boundary`
+     *  event). `trigger` separates an automatic (context-full) compaction from a
+     *  manual `/compact`. Drives a live "compacting" affordance; because a runner
+     *  owns one turn, it naturally clears on the next turn. */
+    compaction?: {
+        trigger: 'auto' | 'manual';
+        atTokens?: number | null;
+    } | null;
     artifacts?: UniversalArtifact[];
     interactions?: UniversalInteraction[];
     queued?: UniversalQueuedTask[];

package/packages/kernel/dist/protocol/index.js

@@ -16,7 +16,7 @@ export function emptySnapshot() {
     return { phase: 'idle', updatedAt: 0 };
 }
 const APPEND_FIELDS = ['text', 'reasoning'];
-const STRUCT_FIELDS = ['plan', 'toolCalls', 'subAgents', 'usage', 'artifacts', 'interactions', 'queued'];
+const STRUCT_FIELDS = ['plan', 'toolCalls', 'subAgents', 'usage', 'artifacts', 'interactions', 'queued', 'compaction'];
 const SCALAR_FIELDS = ['phase', 'taskId', 'sessionId', 'agent', 'model', 'effort', 'prompt', 'activity', 'error', 'incomplete', 'startedAt', 'updatedAt', 'anchor'];
 export function diffSnapshot(prev, next) {
     const patch = {};

package/packages/kernel/dist/runtime/hub.d.ts

@@ -46,6 +46,13 @@ export declare class Hub implements LoomIO {
     forkSession(input: ForkSessionInput): Promise<{
         sessionKey: string;
     }>;
+    rewindSession(input: {
+        sessionKey: string;
+        atTaskId: string;
+        anchor?: string | null;
+    }): Promise<{
+        sessionKey: string;
+    }>;
     private enqueue;
     private runNow;
     private promoteNext;

package/packages/kernel/dist/runtime/hub.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { diffSnapshot, emptySnapshot, makeSessionKey, splitSessionKey, } from '../protocol/index.js';
 import { SessionRunner } from './session-runner.js';
 import { buildForkSeed } from './fork.js';
+import { normalizeImageAttachments } from '../attachments.js';
 export class Hub {
     deps;
     sessions = new Map();
@@ -143,6 +144,52 @@ export class Hub {
         this.deps.log?.(`[hub] forked ${input.fromSessionKey} -> ${agent}:${newId} (${mode}${anchor ? `, anchor ${anchor}` : ''}, ${kept.length}/${turns.length} turns)`);
         return { sessionKey: makeSessionKey(agent, newId) };
     }
+    // Rewind `sessionKey` IN PLACE to a turn boundary: drop the transcript after `atTaskId` (the
+    // last KEPT turn) and stamp a pendingRewind the next prompt() consumes (resume the SAME native
+    // session at the kept boundary, NO fork). The session id — managed AND native — is unchanged;
+    // only the dropped tip leaves the active path. Requires a rewind-capable driver, a store that
+    // can truncate, and a resolvable native anchor at the cut; otherwise throws so the caller can
+    // fall back (append on the same session, or a fork).
+    async rewindSession(input) {
+        const { agent, sessionId } = splitSessionKey(input.sessionKey);
+        const driver = this.deps.drivers.get(agent);
+        if (!driver)
+            throw new Error(`No driver registered for agent "${agent}"`);
+        if (!driver.capabilities?.rewind)
+            throw new Error(`agent "${agent}" has no in-place rewind`);
+        if (!this.deps.sessionStore.truncateTurns || !this.deps.sessionStore.history) {
+            throw new Error('session store cannot rewind (no truncateTurns/history)');
+        }
+        const rec = await this.deps.sessionStore.get(agent, sessionId);
+        if (!rec)
+            throw new Error(`rewind: session ${input.sessionKey} not found`);
+        const nativeId = rec.nativeSessionId || sessionId;
+        const turns = await this.deps.sessionStore.history(agent, sessionId).catch(() => []);
+        const cut = turns.findIndex((t) => t.taskId === input.atTaskId);
+        if (cut < 0)
+            throw new Error(`rewind point ${input.atTaskId} not found in ${input.sessionKey}`);
+        if (cut === turns.length - 1)
+            throw new Error(`rewind point ${input.atTaskId} is the tail — nothing to regenerate`);
+        const kept = turns.slice(0, cut + 1);
+        // Native rebranch boundary: explicit override → the kept tail's recorded anchor. No anchor =
+        // the kept turn never recorded one (e.g. a native-only import) — can't rebranch, so refuse.
+        const anchor = input.anchor ?? kept[kept.length - 1]?.anchor ?? null;
+        if (!anchor)
+            throw new Error(`rewind: no native anchor at ${input.atTaskId} in ${input.sessionKey}`);
+        // Drop the tip from the managed transcript, then stamp the rewind intent. The native store is
+        // untouched here — the next dispatch rebranches it at `anchor` via AgentTurnInput.rewind.
+        await this.deps.sessionStore.truncateTurns(agent, sessionId, input.atTaskId);
+        const last = kept[kept.length - 1];
+        rec.model = last?.model ?? rec.model ?? null;
+        rec.effort = last?.effort ?? rec.effort ?? null;
+        rec.nativeSessionId = nativeId;
+        rec.runState = 'completed';
+        rec.runDetail = null;
+        rec.pendingRewind = { anchor };
+        await this.deps.sessionStore.save(rec);
+        this.deps.log?.(`[hub] rewound ${input.sessionKey} to ${input.atTaskId} (anchor ${anchor}, kept ${kept.length}/${turns.length} turns)`);
+        return { sessionKey: input.sessionKey };
+    }
     enqueue(item) {
         const q = this.waiting.get(item.sessionKey) ?? [];
         q.push(item);
@@ -174,6 +221,9 @@ export class Hub {
         // first turn keeps the intent, so the retry forks again). Native mode resumes the PARENT's
         // native id with the fork flag; seed mode starts fresh and replays the copied transcript.
         const pendingFork = rec && !rec.nativeSessionId ? rec.pendingFork ?? null : null;
+        // A rewind keeps the SAME native id (it resumes+rebranches this session), so — unlike a fork —
+        // it is NOT gated on a missing native id. Fork and rewind never coexist on one record.
+        const pendingRewind = rec?.pendingRewind ?? null;
         const injection = await this.deps.modelResolver.resolve(agent, { model: input.model, profileId: null }).catch(() => null);
         const model = injection?.model ?? input.model ?? null;
         const effort = input.effort ?? null;
@@ -191,6 +241,7 @@ export class Hub {
         const systemPrompt = await this.composeSystemPrompt(agent, workdir, !preExisted || pendingFork?.mode === 'seed');
         let driverSessionId = rec?.nativeSessionId || (input.sessionKey ? sessionId : null);
         let driverFork = null;
+        let driverRewind = null;
         let driverPrompt = input.prompt;
         if (pendingFork) {
             if (pendingFork.mode === 'native' && pendingFork.parentNativeSessionId) {
@@ -204,11 +255,20 @@ export class Hub {
                     driverPrompt = `${seed}\n\n${input.prompt}`;
             }
         }
+        else if (pendingRewind) {
+            // In-place rewind: resume THIS session's own native id but rebranch at the kept boundary
+            // (no fork), so the dropped tip leaves the active path and the prompt regenerates from it.
+            driverSessionId = rec?.nativeSessionId || sessionId;
+            driverRewind = { anchor: pendingRewind.anchor };
+        }
         const turnInput = {
             prompt: driverPrompt,
-            attachments: input.attachments,
+            // Oversized images are downscaled here and in steer() — the two dispatch chokepoints —
+            // so every driver (built-in or host-plugged) sends model-safe attachments.
+            attachments: await normalizeImageAttachments(input.attachments, this.deps.log),
             sessionId: driverSessionId,
             fork: driverFork,
+            rewind: driverRewind,
             workdir,
             model, effort, systemPrompt,
             env: spawn.env,
@@ -239,6 +299,20 @@ export class Hub {
                     this.deps.log?.(`[hub] pendingFork clear failed ${sessionKey}: ${e?.message || e}`);
                 }
             }
+            // A rewind materialized (the turn ran and rebranched the native session) — consume the
+            // intent so a normal follow-up prompt appends to the regenerated tip instead of rewinding.
+            if (pendingRewind && result.sessionId) {
+                try {
+                    const settled = await this.deps.sessionStore.get(agent, sessionId);
+                    if (settled?.pendingRewind) {
+                        settled.pendingRewind = null;
+                        await this.deps.sessionStore.save(settled);
+                    }
+                }
+                catch (e) {
+                    this.deps.log?.(`[hub] pendingRewind clear failed ${sessionKey}: ${e?.message || e}`);
+                }
+            }
             // Persist the completed turn's final snapshot as a transcript entry. The runner's
             // snapshot is stable once done (a follow-up prompt spawns a fresh runner+snapshot).
             try {
@@ -396,7 +470,7 @@ export class Hub {
     }
     async steer(taskId, prompt, attachments) {
         const r = this.runnersByTask.get(taskId);
-        return r ? r.steer(prompt, attachments) : false;
+        return r ? r.steer(prompt, await normalizeImageAttachments(attachments, this.deps.log)) : false;
     }
     interact(promptId, action, value) {
         for (const r of this.runnersByTask.values()) {

package/packages/kernel/dist/runtime/session-runner.js

@@ -96,6 +96,9 @@ export class SessionRunner {
             case 'usage':
                 this.snapshot.usage = mergeUsage(this.snapshot.usage, e.usage);
                 break;
+            case 'compaction':
+                this.snapshot.compaction = { trigger: e.trigger, atTokens: e.atTokens ?? null };
+                break;
             // toolCalls is the structured SSOT; activity is its derived human-readable view.
             // A driver that streams explicit `activity` lines (e.g. echo) owns activity directly;
             // any driver that emits structured tool/subagent events gets the projection for free.