pikiloom 0.4.70 → 0.4.72

package/dist/agent/drivers/codex.js

@@ -276,9 +276,11 @@ export async function pauseCodexGoal(threadId) {
 export async function resumeCodexGoal(threadId) {
     return setCodexGoal({ threadId, status: 'active' });
 }
-const EFFORT_MAP = {
-    low: 'low', medium: 'medium', high: 'high', min: 'minimal', max: 'xhigh',
-};
+// Codex (GPT-5.6+) accepts low / medium / high / xhigh / max / ultra as native reasoning levels,
+// so the effort token is forwarded to the app-server verbatim. Only `min` is an alias for the
+// CLI's `minimal`. (Historically `max` was folded to `xhigh` because older Codex had no `max`
+// rung — that clamp is gone now that 5.6 exposes `max`/`ultra` directly.)
+const EFFORT_MAP = { min: 'minimal' };
 function mapEffort(effort) { return EFFORT_MAP[effort] ?? effort; }
 function isCodexToolCallItem(item) {
     return item?.type === 'dynamicToolCall' || item?.type === 'mcpToolCall' || item?.type === 'collabAgentToolCall';
@@ -808,7 +810,7 @@ export function humanizeCodexError(raw) {
         const model = match[1];
         return `Codex 正在使用 ChatGPT 账号登录，无法运行第三方模型「${model}」。`
             + `请在「智能体配置」页接入该模型的供应商（填入 Base URL 与 API Key），添加对应模型档案并绑定到 Codex，`
-            + `或改用 Codex 原生模型（如 gpt-5.5）。`;
+            + `或改用 Codex 原生模型（如 gpt-5.6-sol）。`;
     }
     return raw;
 }

package/dist/cli/kernel-app.js

@@ -17,7 +17,11 @@ import { resolveAgentInjection } from '../model/injector.js';
 // queue, wire) is live here.
 const DEMO_MODELS = {
     claude: [{ id: 'claude-opus-4-8', label: 'Opus 4.8', providerName: 'anthropic', contextWindow: 200000 }],
-    codex: [{ id: 'gpt-5.5-codex', label: 'GPT-5.5 Codex', providerName: 'openai', contextWindow: 400000 }],
+    codex: [
+        { id: 'gpt-5.6-sol', label: 'GPT-5.6-Sol', providerName: 'openai', contextWindow: 372000 },
+        { id: 'gpt-5.6-terra', label: 'GPT-5.6-Terra', providerName: 'openai', contextWindow: 372000 },
+        { id: 'gpt-5.6-luna', label: 'GPT-5.6-Luna', providerName: 'openai', contextWindow: 372000 },
+    ],
     gemini: [{ id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro', providerName: 'google', contextWindow: 1000000 }],
     opencode: [{ id: 'claude-sonnet-4-6', label: 'OpenCode · Sonnet 4.6 (ACP)', providerName: 'opencode', contextWindow: 200000 }],
     echo: [{ id: 'echo-1', label: 'Echo (hermetic)', providerName: 'local', contextWindow: 8192 }],

package/dist/core/config/runtime-config.js

@@ -1,7 +1,13 @@
 import { normalizeClaudeModelId } from '../../agent/index.js';
+/** Account-scoped GPT-5.6 variants the Codex model catalog currently advertises. */
+export const CODEX_56_MODEL_IDS = [
+    'gpt-5.6-sol',
+    'gpt-5.6-terra',
+    'gpt-5.6-luna',
+];
 export const DEFAULT_AGENT_MODELS = {
     claude: 'claude-opus-4-8',
-    codex: 'gpt-5.5',
+    codex: CODEX_56_MODEL_IDS[0],
     gemini: 'gemini-3.1-pro-preview',
     hermes: 'anthropic/claude-sonnet-4',
 };
@@ -178,16 +184,39 @@ export function effortLabel(id) {
 // so per-model/provider rules stay in one place. Labels come from effortLabel() so the picker
 // and the live status row can never diverge.
 const effortLevels = (...ids) => ids.map(id => ({ id, label: effortLabel(id) }));
+const CODEX_BASE_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+// Per-model Codex reasoning ladders. GPT-5.6 adds the native `max` rung (sol/terra also expose
+// `ultra`), which older Codex models (5.5/5.4) do not support — so the picker must vary by model,
+// never a single flat list. For codex, `max`/`ultra` are REAL CLI reasoning levels (not the
+// claude display alias): they are dispatched verbatim (see splitEffortForAgent / the codex driver).
+const CODEX_56_EFFORTS = {
+    'gpt-5.6-sol': [...CODEX_BASE_EFFORTS, 'max', ULTRA_EFFORT],
+    'gpt-5.6-terra': [...CODEX_BASE_EFFORTS, 'max', ULTRA_EFFORT],
+    'gpt-5.6-luna': [...CODEX_BASE_EFFORTS, 'max'],
+};
 const AGENT_EFFORT_LEVELS = {
     claude: effortLevels('low', 'medium', 'high', 'xhigh', 'max', ULTRA_EFFORT),
-    codex: effortLevels('low', 'medium', 'high', 'xhigh'),
+    codex: effortLevels(...CODEX_BASE_EFFORTS),
     // gemini intentionally has no UI-exposed effort levels: pikiloom sends it no reasoning-effort
     // (see the gemini→null guards in InputComposer). Add a gemini entry here to surface low/high.
     hermes: effortLevels('minimal', 'low', 'medium', 'high', 'xhigh'),
 };
 // Valid effort levels for a given (agent, model, providerKind). Returns [] when reasoning
 // effort does not apply (the UI then hides the selector entirely). model/providerKind are the
-// seam for per-model rules — add them here and nowhere else.
-export function effortOptionsFor(agent, _model, _providerKind) {
+// seam for per-model rules — add them here and nowhere else. A known GPT-5.6 codex model unlocks
+// its `max`/`ultra` rungs; every other codex model (incl. BYOK) keeps the base low→xhigh ladder.
+export function effortOptionsFor(agent, model, _providerKind) {
+    if (agent === 'codex' && model && model in CODEX_56_EFFORTS) {
+        return effortLevels(...CODEX_56_EFFORTS[model]);
+    }
     return AGENT_EFFORT_LEVELS[agent] ?? [];
 }
+// Reconcile the two meanings of the effort token before dispatch. Codex (GPT-5.6+) treats
+// `max`/`ultra` as NATIVE reasoning levels, so its token must reach the CLI verbatim — never fold
+// `ultra` into `max`, and never turn on the (claude-only) workflow orchestration. For every other
+// agent `ultra` stays a display alias that decomposes to `max` effort + workflow (decomposeEffortSelection).
+export function splitEffortForAgent(agent, raw) {
+    if (agent === 'codex')
+        return { effort: trimmed(raw).toLowerCase(), workflow: false };
+    return decomposeEffortSelection(raw);
+}

package/dist/dashboard/routes/agents.js

@@ -7,7 +7,7 @@ import { loadUserConfig, saveUserConfig, applyUserConfig } from '../../core/conf
 import { setAgentBoundModelId } from '../../agent/index.js';
 import { getAgentUpdateState, checkAgentLatestVersion, manualAgentUpdate } from '../../agent/auto-update.js';
 import { getDriver, getDriverCapabilities } from '../../agent/driver.js';
-import { decomposeEffortSelection, effortOptionsFor } from '../../core/config/runtime-config.js';
+import { splitEffortForAgent, effortOptionsFor } from '../../core/config/runtime-config.js';
 import { getActiveProfile, getProvider, peekProviderModelList, prefetchProviderModels, } from '../../model/index.js';
 import { DASHBOARD_TIMEOUTS } from '../../core/constants.js';
 import { withTimeoutFallback } from '../../core/utils.js';
@@ -326,7 +326,6 @@ app.post('/api/runtime-agent', async (c) => {
     const targetAgent = body?.agent;
     const model = typeof body?.model === 'string' ? body.model.trim() : '';
     const rawEffort = typeof body?.effort === 'string' ? body.effort.trim().toLowerCase() : '';
-    const { effort, workflow: effortWorkflow } = decomposeEffortSelection(rawEffort);
     const hasEffort = rawEffort !== '';
     const botRef = runtime.getBotRef();
     if (defaultAgent != null) {
@@ -358,6 +357,9 @@ app.post('/api/runtime-agent', async (c) => {
                 botRef.setModelForAgent(targetAgent, model);
         }
         if (hasEffort) {
+            // Codex keeps `max`/`ultra` as native reasoning levels; claude decomposes `ultra` into
+            // `max` effort + workflow. splitEffortForAgent reconciles both before we persist the default.
+            const { effort, workflow: effortWorkflow } = splitEffortForAgent(targetAgent, rawEffort);
             runtime.runtimePrefs.efforts[targetAgent] = effort;
             runtime.setEffortEnv(targetAgent, effort);
             if (targetAgent === 'claude')

package/dist/dashboard/session-control.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { getProjectSkillPaths, listSkills, stageSessionFiles, ensureManagedSession, findPikiloomSession, getDriverCapabilities, isPendingSessionId } from '../agent/index.js';
 import { loadUserConfig } from '../core/config/user-config.js';
-import { decomposeEffortSelection } from '../core/config/runtime-config.js';
+import { splitEffortForAgent } from '../core/config/runtime-config.js';
 import { runtime } from './runtime.js';
 const KNOWN_AGENTS = new Set(['claude', 'codex', 'gemini', 'hermes']);
 function parseGoalSlash(prompt) {
@@ -78,7 +78,7 @@ export async function queueDashboardSessionTask(request) {
         : runtime.getRuntimeDefaultAgent(config);
     const modelId = typeof request.model === 'string' ? request.model.trim() : '';
     const profileId = resolveProfileIdOverride(request.profileId);
-    const { effort: splitEffort, workflow: ultraWorkflow } = decomposeEffortSelection(typeof request.effort === 'string' ? request.effort : '');
+    const { effort: splitEffort, workflow: ultraWorkflow } = splitEffortForAgent(resolvedAgent, typeof request.effort === 'string' ? request.effort : '');
     const thinkingEffort = resolvedAgent === 'gemini' ? '' : splitEffort;
     const workflowEnabled = ultraWorkflow || request.workflow === true;
     const goalCmd = parseGoalSlash(request.prompt || '');
@@ -171,7 +171,7 @@ export function forkDashboardSessionTask(request) {
     }
     const modelId = typeof request.model === 'string' ? request.model.trim() : '';
     const profileId = resolveProfileIdOverride(request.profileId);
-    const { effort: splitEffort, workflow: ultraWorkflow } = decomposeEffortSelection(typeof request.effort === 'string' ? request.effort : '');
+    const { effort: splitEffort, workflow: ultraWorkflow } = splitEffortForAgent(agent, typeof request.effort === 'string' ? request.effort : '');
     const thinkingEffort = agent === 'gemini' ? '' : splitEffort;
     let prompt = request.prompt;
     const skillResult = prompt ? resolveSkillFromPrompt(request.workdir, prompt) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.70",
+  "version": "0.4.72",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/dist/contracts/driver.d.ts

@@ -6,6 +6,9 @@ export interface AgentTurnInput {
     fork?: {
         anchor?: string | null;
     } | null;
+    rewind?: {
+        anchor?: string | null;
+    } | null;
     workdir: string;
     model?: string | null;
     effort?: string | null;
@@ -55,6 +58,10 @@ export type DriverEvent = {
 } | {
     type: 'activity';
     line: string;
+} | {
+    type: 'compaction';
+    trigger: 'auto' | 'manual';
+    atTokens?: number | null;
 };
 export type SteerFn = (prompt: string, attachments?: string[]) => Promise<boolean>;
 export interface DriverContext {
@@ -106,6 +113,7 @@ export interface AgentDriver {
         resume?: boolean;
         tui?: boolean;
         fork?: boolean;
+        rewind?: boolean;
     };
     run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
     tui?(input: TuiInput): TuiSpec;

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

@@ -25,6 +25,9 @@ export interface CoreSessionRecord {
         anchor: string | null;
         mode: 'native' | 'seed';
     } | null;
+    pendingRewind?: {
+        anchor: string | null;
+    } | null;
 }
 export interface SessionStore {
     ensure(agent: string, opts: {
@@ -48,6 +51,7 @@ export interface 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>;
 }
 export interface ModelInjection {
     model?: string | null;

package/packages/kernel/dist/contracts/surface.d.ts

@@ -23,6 +23,13 @@ export interface LoomIO {
     forkSession(input: ForkSessionInput): Promise<{
         sessionKey: string;
     }>;
+    rewindSession(input: {
+        sessionKey: string;
+        atTaskId: string;
+        anchor?: string | null;
+    }): Promise<{
+        sessionKey: string;
+    }>;
     stop(sessionKey: string): boolean;
     steer(taskId: string, prompt: string, attachments?: string[]): Promise<boolean>;
     interact(promptId: string, action: 'select' | 'text' | 'skip' | 'cancel', value?: string): boolean;

package/packages/kernel/dist/drivers/claude.d.ts

@@ -9,6 +9,7 @@ export declare class ClaudeDriver implements AgentDriver {
         resume: boolean;
         tui: boolean;
         fork: boolean;
+        rewind: boolean;
     };
     constructor(bin?: string);
     tui(input: TuiInput): TuiSpec;
@@ -25,6 +26,8 @@ export declare class ClaudeDriver implements AgentDriver {
 }
 export declare function claudeResumeArgs(sessionId: string, fork?: {
     anchor?: string | null;
+} | null, rewind?: {
+    anchor?: string | null;
 } | null): string[];
 export declare function handleClaudeEvent(ev: any, s: any, emit: (e: DriverEvent) => void): void;
 export declare function claudeBgHoldCapMs(): number;

package/packages/kernel/dist/drivers/claude.js

@@ -9,7 +9,7 @@ import { attachedFileNote, contextPercent, createLineBuffer, imageMimeForFile, p
 export class ClaudeDriver {
     bin;
     id = 'claude';
-    capabilities = { steer: true, interact: false, resume: true, tui: true, fork: true };
+    capabilities = { steer: true, interact: false, resume: true, tui: true, fork: true, rewind: true };
     constructor(bin = 'claude') {
         this.bin = bin;
     }
@@ -43,7 +43,7 @@ export class ClaudeDriver {
         if (input.effort)
             args.push('--effort', input.effort === 'ultra' ? 'max' : input.effort); // request extended thinking (ultra is a display-only alias for max)
         if (input.sessionId)
-            args.push(...claudeResumeArgs(input.sessionId, input.fork));
+            args.push(...claudeResumeArgs(input.sessionId, input.fork, input.rewind));
         if (input.systemPrompt)
             args.push('--append-system-prompt', input.systemPrompt);
         if (input.mcpConfigPath)
@@ -369,14 +369,19 @@ export class ClaudeDriver {
 }
 // The --resume flag family for one turn: plain resume appends to the session; a fork branches
 // a NEW session off it (--fork-session), optionally cut at an inclusive keep-boundary record
-// uuid (--resume-session-at). Pure so tests can pin the arg contract without spawning.
-export function claudeResumeArgs(sessionId, fork) {
+// uuid (--resume-session-at); a rewind cuts at that boundary WITHOUT --fork-session, so claude
+// rebranches the SAME session in place (the transcript is a parentUuid tree — the dropped tip
+// becomes a dead sibling and leaves the active path). Pure so tests pin the arg contract.
+export function claudeResumeArgs(sessionId, fork, rewind) {
     const args = ['--resume', sessionId];
     if (fork) {
         args.push('--fork-session');
         if (fork.anchor)
             args.push('--resume-session-at', fork.anchor);
     }
+    else if (rewind?.anchor) {
+        args.push('--resume-session-at', rewind.anchor);
+    }
     return args;
 }
 function claudeUsageOf(s) {
@@ -468,6 +473,15 @@ export function handleClaudeEvent(ev, s, emit) {
         }
         s.model = ev.model ?? s.model;
         s.contextWindow = claudeEffectiveContextWindow(claudeContextWindowFromModel(s.model)) ?? s.contextWindow;
+        // Claude compacted the running context (subtype `compact_boundary`): `trigger` is
+        // `auto` (the context filled up) or `manual` (a `/compact` command). Surface it live
+        // so a terminal can show a "compacting" affordance; the compacted summary itself lands
+        // in the native transcript and settles into a divider separately.
+        if (ev.subtype === 'compact_boundary') {
+            const meta = (ev.compact_metadata ?? {});
+            emit({ type: 'compaction', trigger: meta.trigger === 'manual' ? 'manual' : 'auto', atTokens: typeof meta.pre_tokens === 'number' ? meta.pre_tokens : null });
+            return;
+        }
         // Live thinking progress (system/thinking_tokens, ~every 1.4s of sustained thinking): during
         // extended thinking a subscription account streams no plaintext (signature_delta only) and no
         // usage until the message settles, so without projecting these the terminal shows a dead

package/packages/kernel/dist/drivers/codex.js

@@ -320,6 +320,9 @@ export class CodexDriver {
                 state.sessionId = threadId;
                 ctx.emit({ type: 'session', sessionId: threadId });
             }
+            // Codex emits no explicit compaction event, so track peak occupancy: a sharp
+            // mid-turn drop is an auto-compaction, surfaced as a live `compaction` signal.
+            let compactPeakTokens = 0;
             srv.onNotification((method, params) => {
                 if (params?.threadId && params.threadId !== state.sessionId && method !== 'turn/started')
                     return;
@@ -444,6 +447,21 @@ export class CodexDriver {
                     case 'thread/tokenUsage/updated': {
                         applyCodexTokenUsage(state, params?.tokenUsage || params?.usage);
                         ctx.emit({ type: 'usage', usage: codexUsageOf(state) });
+                        // No explicit boundary event: a sharp drop from a high peak IS a compaction.
+                        // Conservative thresholds (peak ≥ 50% of window, drop ≥ 25% of window) so
+                        // ordinary turn churn never trips it; re-baseline so it fires once per drop.
+                        {
+                            const cw = state.contextWindow ?? 0;
+                            const used = state.contextUsed ?? 0;
+                            if (cw > 0 && used >= 0) {
+                                if (used > compactPeakTokens)
+                                    compactPeakTokens = used;
+                                else if (compactPeakTokens / cw >= 0.5 && (compactPeakTokens - used) / cw >= 0.25) {
+                                    ctx.emit({ type: 'compaction', trigger: 'auto', atTokens: compactPeakTokens });
+                                    compactPeakTokens = used;
+                                }
+                            }
+                        }
                         break;
                     }
                     case 'turn/completed': {

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/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

@@ -143,6 +143,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 +220,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 +240,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 +254,18 @@ 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,
             sessionId: driverSessionId,
             fork: driverFork,
+            rewind: driverRewind,
             workdir,
             model, effort, systemPrompt,
             env: spawn.env,
@@ -239,6 +296,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 {

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.