@modelprofile.com/flexharness 3.5.0 → 3.7.0

package/dist_ts/utils.slashcommands.d.ts

@@ -0,0 +1,7 @@
+import type { TFlexSlashCommandParseResult } from './interfaces.js';
+export declare const FLEX_SLASH_COMMAND_MAX_INPUT_BYTES: number;
+export declare const FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE = "Create or update `AGENTS.md` for this repository.\n\nThe goal is a compact instruction file that helps future OpenCode sessions avoid mistakes and ramp up quickly. Every line should answer: \"Would an agent likely miss this without help?\" If not, leave it out.\n\nUser-provided focus or constraints (honor these):\n$ARGUMENTS\n\n## How to investigate\n\nRead the highest-value sources first:\n- `README*`, root manifests, workspace config, lockfiles\n- build, test, lint, formatter, typecheck, and codegen config\n- CI workflows and pre-commit / task runner config\n- existing instruction files (`AGENTS.md`, `CLAUDE.md`, `.cursor/rules/`, `.cursorrules`, `.github/copilot-instructions.md`)\n- repo-local OpenCode config such as `opencode.json`\n\nIf architecture is still unclear after reading config and docs, inspect a small number of representative code files to find the real entrypoints, package boundaries, and execution flow. Prefer reading the files that explain how the system is wired together over random leaf files.\n\nPrefer executable sources of truth over prose. If docs conflict with config or scripts, trust the executable source and only keep what you can verify.\n\n## What to extract\n\nLook for the highest-signal facts for an agent working in this repo:\n- exact developer commands, especially non-obvious ones\n- how to run a single test, a single package, or a focused verification step\n- required command order when it matters, such as `lint -> typecheck -> test`\n- monorepo or multi-package boundaries, ownership of major directories, and the real app/library entrypoints\n- framework or toolchain quirks: generated code, migrations, codegen, build artifacts, special env loading, dev servers, infra deploy flow\n- repo-specific style or workflow conventions that differ from defaults\n- testing quirks: fixtures, integration test prerequisites, snapshot workflows, required services, flaky or expensive suites\n- important constraints from existing instruction files worth preserving\n\nGood `AGENTS.md` content is usually hard-earned context that took reading multiple files to infer.\n\n## Questions\n\nOnly ask the user questions if the repo cannot answer something important. Use the `question` tool for one short batch at most.\n\nGood questions:\n- undocumented team conventions\n- branch / PR / release expectations\n- missing setup or test prerequisites that are known but not written down\n\nDo not ask about anything the repo already makes clear.\n\n## Writing rules\n\nInclude only high-signal, repo-specific guidance such as:\n- exact commands and shortcuts the agent would otherwise guess wrong\n- architecture notes that are not obvious from filenames\n- conventions that differ from language or framework defaults\n- setup requirements, environment quirks, and operational gotchas\n- references to existing instruction sources that matter\n\nExclude:\n- generic software advice\n- long tutorials or exhaustive file trees\n- obvious language conventions\n- speculative claims or anything you could not verify\n- content better stored in another file referenced via `opencode.json` `instructions`\n\nWhen in doubt, omit.\n\nPrefer short sections and bullets. If the repo is simple, keep the file simple. If the repo is large, summarize the few structural facts that actually change how an agent should work.\n\nIf `AGENTS.md` already exists in the active workspace, improve it in place rather than rewriting blindly. Preserve verified useful guidance, delete fluff or stale claims, and reconcile it with the current codebase.\n";
+export declare function isValidSlashCommandName(name: string): boolean;
+export declare function parseSlashCommand(input: string): TFlexSlashCommandParseResult;
+export declare function slashCommandTemplateHints(template: string): string[];
+export declare function expandSlashCommandTemplate(template: string, rawArguments: string, arguments_: readonly string[]): string;

package/dist_ts/utils.slashcommands.js

@@ -0,0 +1,164 @@
+import { FlexHarnessValidationError } from './errors.js';
+export const FLEX_SLASH_COMMAND_MAX_INPUT_BYTES = 768 * 1024;
+const slashCommandNamePattern = /^[a-z][a-z0-9-]{0,63}$/u;
+const slashCommandPattern = /^\/([a-z][a-z0-9-]{0,63})(?:$|(\s+)([\s\S]*))$/u;
+const slashCommandArgumentsPattern = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
+const slashCommandQuoteTrimPattern = /^["']|["']$/g;
+const slashCommandPlaceholderPattern = /\$(\d+)/g;
+const slashCommandAllPlaceholderPattern = /\$ARGUMENTS|\$(\d+)/g;
+export const FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE = `Create or update \`AGENTS.md\` for this repository.
+
+The goal is a compact instruction file that helps future OpenCode sessions avoid mistakes and ramp up quickly. Every line should answer: "Would an agent likely miss this without help?" If not, leave it out.
+
+User-provided focus or constraints (honor these):
+$ARGUMENTS
+
+## How to investigate
+
+Read the highest-value sources first:
+- \`README*\`, root manifests, workspace config, lockfiles
+- build, test, lint, formatter, typecheck, and codegen config
+- CI workflows and pre-commit / task runner config
+- existing instruction files (\`AGENTS.md\`, \`CLAUDE.md\`, \`.cursor/rules/\`, \`.cursorrules\`, \`.github/copilot-instructions.md\`)
+- repo-local OpenCode config such as \`opencode.json\`
+
+If architecture is still unclear after reading config and docs, inspect a small number of representative code files to find the real entrypoints, package boundaries, and execution flow. Prefer reading the files that explain how the system is wired together over random leaf files.
+
+Prefer executable sources of truth over prose. If docs conflict with config or scripts, trust the executable source and only keep what you can verify.
+
+## What to extract
+
+Look for the highest-signal facts for an agent working in this repo:
+- exact developer commands, especially non-obvious ones
+- how to run a single test, a single package, or a focused verification step
+- required command order when it matters, such as \`lint -> typecheck -> test\`
+- monorepo or multi-package boundaries, ownership of major directories, and the real app/library entrypoints
+- framework or toolchain quirks: generated code, migrations, codegen, build artifacts, special env loading, dev servers, infra deploy flow
+- repo-specific style or workflow conventions that differ from defaults
+- testing quirks: fixtures, integration test prerequisites, snapshot workflows, required services, flaky or expensive suites
+- important constraints from existing instruction files worth preserving
+
+Good \`AGENTS.md\` content is usually hard-earned context that took reading multiple files to infer.
+
+## Questions
+
+Only ask the user questions if the repo cannot answer something important. Use the \`question\` tool for one short batch at most.
+
+Good questions:
+- undocumented team conventions
+- branch / PR / release expectations
+- missing setup or test prerequisites that are known but not written down
+
+Do not ask about anything the repo already makes clear.
+
+## Writing rules
+
+Include only high-signal, repo-specific guidance such as:
+- exact commands and shortcuts the agent would otherwise guess wrong
+- architecture notes that are not obvious from filenames
+- conventions that differ from language or framework defaults
+- setup requirements, environment quirks, and operational gotchas
+- references to existing instruction sources that matter
+
+Exclude:
+- generic software advice
+- long tutorials or exhaustive file trees
+- obvious language conventions
+- speculative claims or anything you could not verify
+- content better stored in another file referenced via \`opencode.json\` \`instructions\`
+
+When in doubt, omit.
+
+Prefer short sections and bullets. If the repo is simple, keep the file simple. If the repo is large, summarize the few structural facts that actually change how an agent should work.
+
+If \`AGENTS.md\` already exists in the active workspace, improve it in place rather than rewriting blindly. Preserve verified useful guidance, delete fluff or stale claims, and reconcile it with the current codebase.
+`;
+export function isValidSlashCommandName(name) {
+    return slashCommandNamePattern.test(name);
+}
+function tokenizeSlashCommandArguments(rawArguments) {
+    const tokens = rawArguments.match(slashCommandArgumentsPattern) ?? [];
+    return tokens.map((token) => token.replace(slashCommandQuoteTrimPattern, ''));
+}
+export function parseSlashCommand(input) {
+    if (typeof input !== 'string') {
+        throw new FlexHarnessValidationError('Slash command input must be a string.');
+    }
+    if (!input.startsWith('/'))
+        return Object.freeze({ type: 'not-command' });
+    if (Buffer.byteLength(input, 'utf8') > FLEX_SLASH_COMMAND_MAX_INPUT_BYTES) {
+        return Object.freeze({
+            type: 'malformed',
+            reason: `Slash command input exceeds ${FLEX_SLASH_COMMAND_MAX_INPUT_BYTES} UTF-8 bytes.`,
+        });
+    }
+    const match = slashCommandPattern.exec(input);
+    if (!match) {
+        return Object.freeze({
+            type: 'malformed',
+            reason: 'Slash command syntax is invalid.',
+        });
+    }
+    const arguments_ = tokenizeSlashCommandArguments(match[3] ?? '');
+    Object.freeze(arguments_);
+    return Object.freeze({
+        type: 'parsed',
+        input,
+        name: match[1],
+        rawArguments: match[3] ?? '',
+        arguments: arguments_,
+    });
+}
+export function slashCommandTemplateHints(template) {
+    const hints = [...new Set(template.match(/\$\d+/g) ?? [])].sort();
+    if (template.includes('$ARGUMENTS'))
+        hints.push('$ARGUMENTS');
+    return hints;
+}
+export function expandSlashCommandTemplate(template, rawArguments, arguments_) {
+    const placeholders = template.match(slashCommandPlaceholderPattern) ?? [];
+    let highestPosition = 0;
+    for (const placeholder of placeholders) {
+        highestPosition = Math.max(highestPosition, Number(placeholder.slice(1)));
+    }
+    const segments = [];
+    let lastIndex = 0;
+    let expandedBytes = 0;
+    for (const match of template.matchAll(slashCommandAllPlaceholderPattern)) {
+        const literal = template.slice(lastIndex, match.index);
+        let replacement;
+        if (match[0] === '$ARGUMENTS') {
+            replacement = rawArguments;
+        }
+        else {
+            const position = Number(match[1]);
+            const argumentIndex = position - 1;
+            replacement = argumentIndex < 0 || argumentIndex >= arguments_.length
+                ? ''
+                : position === highestPosition
+                    ? arguments_.slice(argumentIndex).join(' ')
+                    : arguments_[argumentIndex];
+        }
+        expandedBytes += Buffer.byteLength(literal, 'utf8') + Buffer.byteLength(replacement, 'utf8');
+        if (expandedBytes > FLEX_SLASH_COMMAND_MAX_INPUT_BYTES) {
+            throw new FlexHarnessValidationError('Expanded slash command prompt exceeds the input limit.');
+        }
+        segments.push(literal, replacement);
+        lastIndex = match.index + match[0].length;
+    }
+    segments.push(template.slice(lastIndex));
+    expandedBytes += Buffer.byteLength(segments.at(-1), 'utf8');
+    if (expandedBytes > FLEX_SLASH_COMMAND_MAX_INPUT_BYTES) {
+        throw new FlexHarnessValidationError('Expanded slash command prompt exceeds the input limit.');
+    }
+    let expanded = segments.join('');
+    if (placeholders.length === 0 && !template.includes('$ARGUMENTS') && rawArguments.trim()) {
+        if (expandedBytes + Buffer.byteLength(rawArguments, 'utf8') + 2
+            > FLEX_SLASH_COMMAND_MAX_INPUT_BYTES) {
+            throw new FlexHarnessValidationError('Expanded slash command prompt exceeds the input limit.');
+        }
+        expanded += `\n\n${rawArguments}`;
+    }
+    return expanded;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_migration/v3_legacyflexharness.js

@@ -261,10 +261,14 @@ function createMigrationPlan(storageKey, legacySnapshot) {
             tombstones: [],
         };
         const projectionSnapshot = {
-            schemaVersion: 1,
+            schemaVersion: 2,
             revision: 1,
             messages: stored.messages,
             stagedTerminals: [],
+            reversionSegments: [],
+            revertCursor: 0,
+            excludedRunIds: [],
+            pendingReversionReleases: [],
         };
         const permissionSnapshot = {
             schemaVersion: 1,
@@ -423,4 +427,4 @@ export async function migrateLegacyFlexHarnessSnapshot(storageKey, legacySnapsho
     if (errors.length > 1)
         throw new AggregateError(errors, 'Legacy FlexHarness migration failed.');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v3_legacyflexharness.js","sourceRoot":"","sources":["../../ts_migration/v3_legacyflexharness.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v3_legacyflexharness.js","sourceRoot":"","sources":["../../ts_migration/v3_legacyflexharness.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/flexharness",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "private": false,
   "description": "Provider-neutral model-session runtime with durable history, permissions, typed events, and pluggable local or remote tool execution.",
   "main": "dist_ts/index.js",

package/readme.hints.md

@@ -8,6 +8,7 @@ Implementation findings for flexharness.
 - Public prompts remain JSON-safe. URL strings are converted to `URL` instances only at the private SmartAgent invocation boundary.
 - Prompt attachment payloads exist only in canonical private Agent events. Public messages, prompt results, projection snapshots, and events expose only `attachmentType`, source kind, optional media/name, and decoded size when determinable.
 - Resolver calls start in promise continuations so synchronous throws are observed. The first failure aborts the shared internal signal without awaiting an ignoring sibling; detached tool-provider settlement is observed and late handles are closed.
+- Resource tool composition resolves descriptors per run before provider acquisition, validates duplicate resources and derived namespaces as one set, preserves legacy tool names, and derives bounded resource names from canonical resource/revision and original-tool hashes. Permission identity uses the complete resource digest while provider metadata remains nested below harness-owned attachment metadata.
 
 ## Persistence boundary
 
@@ -21,10 +22,14 @@ Implementation findings for flexharness.
 - Canonical finalization is the cancellation linearization point. Abort returns false once a run starts committing, while the active-run entry continues to block new prompts until finalization and public promotion settle.
 - Permission callbacks wait for the current save tail and then revalidate their run before reading remembered grants, so neither uncommitted grants nor captured callbacks can authorize later work.
 - Detached tool-provider settlement remains tracked after prompt finalization. Failed late handle closure stays owned by its storage state and is retried by a later retirement or disposal call.
+- A composed tool handle closes resource and application handles in reverse acquisition order. It attempts every close, aggregates failures, marks only successful handles complete, and retains the composite closure so later lifecycle drains retry exactly the failed handles.
 - Scope retirement fences older resolver calls and late state admissions, drains the complete resolved storage namespace, and evicts only the exact cached state promise. It never deletes the durable snapshot. Applications must close admission across every resolver alias before retirement because aliases are unknowable before resolution.
 - Context compaction runs under immutable async invocation context rather than storage-state scope hints. This keeps `scopeId`, `scope`, `storageKey`, and `sessionId` exact for manual, retention, and context-overflow compaction even when aliases share one cached namespace. Autonomous job callbacks use their immutable session-owner context because no later public invocation owns them.
 - Detached tool-provider cleanup and retained session cleanup are owned by the exact loaded storage state. Failed drains retain that ownership and the cached state for retry. Scope retirement cannot await or consume another namespace's cleanup, while full disposal settles all storage drains and orphaned initialization cleanup before aggregating failures.
 - JSON provider release hooks evict non-destructive session wrapper caches after AgentSession and execution-context ownership ends. Failed partial-initialization releases remain storage-scoped orphan ownership and are retried by retirement or disposal.
+- Turn-reversion capture release is idempotent and tombstone-owned. Session deletion aborts same-session commands, waits runtime settlement, releases every durable workspace capture, and only then removes projection data; a failed or unacknowledged release leaves the tombstone and projection available for retry.
+- Projection schema 1 remains read-only compatibility input. Every projection write uses schema 2; legacy and migrated messages have no retroactive undo segments, while new turns establish reversion metadata normally.
+- A loaded schema-1 projection retains its exact durable baseline until the first schema-2 save is confirmed, so a non-committing upgrade failure rolls back without fencing while a post-commit throw reconciles the new schema.
 - `JsonFileFlexHarnessStores.dispose()` is the explicit final drain for file handles whose close failed on the last store operation; failed disposal retains the handle for another call.
 
 ## Tool output boundary

package/readme.md

@@ -89,6 +89,12 @@ const harness = new FlexHarness<IProjectScope>({
     maxPendingAdmissionBytes: 128 * 1024 * 1024,
     maxTerminalEntriesPerSession: 64,
   },
+  reversionLimits: {
+    maxCompletedTurns: 100,
+    maxSegments: 300,
+    maxExcludedRunIds: 1000,
+    maxPendingReversionReleases: 1000,
+  },
   subagents: [
     {
       name: 'researcher',
@@ -110,6 +116,40 @@ const harness = new FlexHarness<IProjectScope>({
 
 `modelRegistry`, `projectRegistry`, `createProjectTools`, and `closeProjectTools` in this example are application-owned integrations. FlexHarness passes the same run `AbortSignal` to the model resolver and tool provider.
 
+## Resource Tool Providers
+
+`resourceToolProviderResolver` composes zero or more resource-owned providers with the existing application `toolProvider`. The resolver runs fresh for every prompt and returns the current resource attachment descriptors:
+
+```typescript
+resourceToolProviderResolver: {
+  async resolveResourceToolProviders({ scope, sessionId, runId, signal }) {
+    const attachments = await resourceRegistry.listAttached({
+      scope,
+      sessionId,
+      runId,
+      signal,
+    });
+    return attachments.map((attachment) => ({
+      resourceId: attachment.resourceId,
+      attachmentRevision: attachment.attachmentRevision,
+      provider: createResourceToolProvider(attachment),
+    }));
+  },
+},
+```
+
+Each descriptor uses the existing `IFlexToolProvider<TScope>` contract. Its provider receives the normal run context and must return a fresh run-scoped handle. The original `toolProvider` remains optional and its tool names remain unchanged. Resource tool names are deterministic and bounded:
+
+1. `resourceIdentity` is the lowercase hexadecimal SHA-256 of `JSON.stringify([resourceId, attachmentRevision])`.
+2. The namespace is `resource_` plus the first 16 digest characters.
+3. The exposed name is `<namespace>__<stem>__<toolDigest>`. `stem` replaces characters outside `[A-Za-z0-9_-]` with `_`, keeps the first 16 characters, and falls back to `tool`; `toolDigest` is the first 12 lowercase hexadecimal characters of SHA-256 over the original tool name.
+
+The resolver accepts at most 128 descriptors per run. `resourceId` must be non-empty and at most 512 UTF-8 bytes, `attachmentRevision` must be a non-negative safe integer, and each original resource tool name must be non-empty and at most 512 UTF-8 bytes. FlexHarness rejects duplicate `resourceId` values even across revisions, duplicate derived namespaces, and duplicate final exposed tool names before model execution. Descriptor identity and namespace validation completes before any application or resource provider is acquired.
+
+Resource permission requests are scoped with the complete 64-character `resourceIdentity`, not the shortened tool namespace. FlexHarness rewrites `kind` to `resource.<resourceIdentity>.<providerKind>` and an optional `rememberKey` to `resource:<resourceIdentity>:<providerRememberKey>`. Harness-owned metadata contains `resourceId`, `attachmentRevision`, `resourceIdentity`, and `toolNamespace`; provider metadata is nested under `providerMetadata`, so it cannot override attachment identity.
+
+FlexHarness owns every acquired handle. Normal close and partial-failure cleanup run in reverse acquisition order, attempt every handle, aggregate multiple failures, and retain failed cleanup for retirement or disposal retry. Cancellation uses the same path. If model resolution fails while a resource provider is still settling, a late returned handle remains tracked and disposal waits for its closure.
+
 ## Foreground Subagents
 
 `subagents` enables a harness-owned built-in tool named `task`. It is available only when at least one definition exists and the current session depth is below `maxSubagentDepth`. An application `toolProvider` must not return its own `task` tool when subagents are configured. The built-in is foreground-only: the parent tool call does not complete until the child prompt reaches a terminal outcome.
@@ -205,6 +245,12 @@ await harness.getSession(scopeId, sessionId);
 await harness.getMessages(scopeId, sessionId);
 await harness.listMessagePage(scopeId, sessionId, { limit: 50, before: cursor });
 await harness.getMessage(scopeId, sessionId, messageId);
+await harness.listSlashCommands(scopeId, sessionId);
+const command = await harness.executeSlashCommand(scopeId, sessionId, '/init focus on tests');
+if (command.type === 'prompt-admission') {
+  console.log(command.admission.queueId, command.admission.runId);
+  await command.admission.completion;
+}
 await harness.updateSession(scopeId, sessionId, { title: 'Renamed', archived: true });
 await harness.updateSession(scopeId, sessionId, { title: null, archived: false });
 await harness.deleteSession(scopeId, sessionId);
@@ -236,6 +282,10 @@ await harness.reconcileToolExecution(scopeId, sessionId, intentId, {
   resolution: 'executed',
   output: { committed: true },
 });
+const undone = await harness.undoSession(scopeId, sessionId);
+console.log(undone.revertedRunId);
+const redone = await harness.redoSession(scopeId, sessionId);
+console.log(redone.restoredRunId);
 await harness.compactSession(scopeId, sessionId);
 await harness.archiveSessionEvents(scopeId, sessionId, compactionEventId);
 await harness.listBackgroundExecutions(scopeId, sessionId);
@@ -263,6 +313,96 @@ The reservation save is the admission point. A save failure produces no start ev
 
 `abort()` returns `true` only while cancellation is still accepted. Terminal persistence is the run's commit point; once it starts, `abort()` returns `false` and the already-fixed terminal outcome completes while the session remains busy.
 
+## Slash Commands
+
+`parseSlashCommand()` is the public strict pure parser. It accepts at most 768 KiB, returns `not-command` for input not starting with `/`, `malformed` for invalid slash syntax, and `parsed` with the exact input, lowercase command name, separator-stripped raw argument text, and OpenCode-compatible quoted tokenization. Command names match `[a-z][a-z0-9-]{0,63}`. Single and double quotes group tokens and are stripped; escapes are not interpreted.
+
+Applications register immutable custom commands at construction:
+
+```typescript
+const harness = new FlexHarness({
+  // scopeResolver, modelResolver, and other options...
+  slashCommands: [
+    {
+      name: 'review-area',
+      description: 'Review one area of the workspace.',
+      template: 'Review $1 with these additional constraints: $ARGUMENTS',
+    },
+    {
+      name: 'refresh-index',
+      description: 'Refresh the application-owned workspace index.',
+      async handler({ scopeId, scope, storageKey, sessionId, rawArguments, arguments, signal }) {
+        return indexer.refresh({
+          scopeId,
+          scope,
+          storageKey,
+          sessionId,
+          rawArguments,
+          arguments,
+          signal,
+        });
+      },
+    },
+  ],
+});
+```
+
+`compact`, `init`, `undo`, and `redo` are reserved. `listSlashCommands()` verifies the scope and session and returns immutable data-only descriptors with `kind`, placeholder `hints`, current immediate availability, and `workspaceReversion`. `compact`, `undo`, `redo`, and custom handlers require an otherwise idle command session. Prompt templates and `init` use the normal bounded FIFO and may wait behind an active prompt. Their descriptors report availability from the same queue-admission conditions used by execution: lifecycle, slash ownership, pending reversion, root-session eligibility, outstanding count, and estimated prompt bytes. A dynamic capacity race may still produce `FlexHarnessQueueFullError` during admission. Only one slash-command execution may own a session at a time.
+
+At most 128 custom commands may be registered. Every registration must be a plain object with exactly one of `template` or `handler`; names must match `[a-z][a-z0-9-]{0,63}`, be unique, and not use a reserved name. Optional descriptions must be non-empty and at most 2048 UTF-8 bytes. Templates must be non-empty and at most 768 KiB, and the expanded prompt must also fit 768 KiB. Registrations are copied and frozen during construction.
+
+`/undo` and `/redo`, plus `undoSession()` and `redoSession()`, move a durable transcript cursor. The direct methods return `{ revertedRunId }` and `{ restoredRunId }`; the slash forms return `{ type: 'operation', name: 'undo' | 'redo' }`. Each committed cursor move emits one `session.history.changed` event with `direction`, `runId`, and the selected session identity. A committed branch emits the same event with `direction: 'branch'` and no `runId`, so controllers should refresh the complete selected session.
+
+A completed root-session turn defines an undo boundary. Failed and cancelled turns after it belong to that unit; failed or cancelled turns before the first completion belong to the first completed unit. Undo applies the unit's segments in reverse order and redo applies them in forward order. Without `turnReversionProvider`, only transcript and future model context move. Hidden messages disappear from `getMessages()`, message pages, exact message lookup, and future model context. Starting a new prompt, template, handler, or compaction from an undone position commits a branch: hidden messages and segments are removed durably and cannot be redone. Successful event archival also commits hidden redo history; a missing compaction or failed archive leaves it intact.
+
+Two horizons bound undo. Retention pruning removes the oldest complete visible units when `reversionLimits` is exceeded. Explicit event archival marks covered turns context-unavailable and prunes complete prefixes that can no longer be rebuilt; FlexHarness never crosses that archive horizon. Manual compaction without archival retains the original events and remains undoable. Schema-1 projection history and sessions migrated from `2.x` have no reversion segments, so historical turns are not retroactively undoable; newly written turns are tracked normally.
+
+`executeSlashCommand()` is the authoritative parser and lookup boundary. Its result distinguishes `not-command`, `malformed`, `unknown`, completed `operation`, bounded `handler-result`, and `prompt-admission`. A prompt admission contains the normal `{ queueId, runId, completion }`; await `admission.completion` for the model result. Unknown commands are never admitted as literal prompts. Known unavailable commands and invalid arguments throw typed FlexHarness errors. Options accept `modelHint`, `system`, `maxSteps`, and `signal`; commands do not accept attachments. Aborting a template or `init` execution cancels its exact queued or started prompt without affecting another queue entry.
+
+Templates replace every `$ARGUMENTS` with untouched raw argument text. `$1` through the highest referenced positional placeholder use tokenized arguments, with the highest position receiving all remaining tokens joined by spaces. Missing positions become empty. A template with no placeholders appends non-empty raw arguments after a blank line. `/init` uses the OpenCode 1.18.15 `AGENTS.md` initialization prompt with provider-neutral active-workspace wording.
+
+Handler context is frozen and contains only the resolved scope identity, session identity, raw and tokenized arguments, and an `AbortSignal`. Handler results are converted with the configured `toolOutputLimits`; `void` becomes JSON `null`. Handler failures use `externalErrorProjector` with source `slashCommand`. Same-session command overlap is rejected, including reentry from a handler. Scope retirement and disposal abort and await active handlers; prompt-admission commands transfer immediately to the normal prompt lifecycle.
+
+### Workspace Reversion Provider
+
+Applications that also need workspace rollback provide all six `IFlexTurnReversionProvider` operations:
+
+```typescript
+import type { IFlexTurnReversionProvider } from '@modelprofile.com/flexharness';
+
+const turnReversionProvider: IFlexTurnReversionProvider<IProjectScope> = {
+  prepare: (context) => workspaceSnapshots.prepare(context),
+  inspectCapture: (context) => workspaceSnapshots.inspectCapture(context),
+  finalize: (context) => workspaceSnapshots.finalize(context),
+  inspectApply: (context) => workspaceSnapshots.inspectApply(context),
+  apply: (context) => workspaceSnapshots.apply(context),
+  release: (context) => workspaceSnapshots.release(context),
+};
+```
+
+`workspaceSnapshots` is application-owned. Every context contains `scopeId`, `scope`, `storageKey`, `sessionId`, `runId`, deterministic `captureId`, and an `AbortSignal`. Apply contexts additionally contain the normalized `reference`, deterministic per-segment `operationId`, and `direction`; release contexts contain the reference.
+
+The protocol is durable and inspectable:
+
+1. FlexHarness persists a `preparing` capture intent before calling `prepare()`, before model or tool execution. The provider must establish exclusive capture ownership for that `storageKey` and retain it until `release()` succeeds.
+2. `inspectCapture()` returns `missing`, `prepared`, `finalized`, or `unknown`. `finalized` includes the reference. `missing` is safe only while the durable state is still `preparing`; a missing prepared or finalizing capture, an `unknown` result, or an inspection failure fences the namespace.
+3. `finalize()` closes the capture and returns its JSON-safe reference. FlexHarness may call it during normal finalization or recovery after `inspectCapture()` reports `prepared`. Failed and cancelled root turns are captured too. A root capture spans foreground subagent effects, although child transcript records remain separate.
+4. Before undo or redo, FlexHarness persists an apply write-ahead record. `inspectApply()` returns `not-applied`, `applied`, or `unknown`. FlexHarness calls `apply()` only for `not-applied`; after an apply error it inspects again before deciding whether to retry or fence. Progress is persisted after each segment, and the transcript cursor moves only after the complete unit succeeds. Known zero-progress failures leave the cursor unchanged and can be retried; partial progress retains the write-ahead record and resumes after restart. Providers should treat `operationId` idempotently.
+5. `release()` relinquishes the capture after branch commitment, retention or archive pruning, session deletion, or other durable removal. It must be idempotent: an unacknowledged release remains persisted and is retried before FlexHarness discards the reference.
+
+Inspection, recovery, finalization, and release use fresh maintenance signals bounded by `agentSessionPolicy.generationLeaseCleanupTimeoutMs`, which defaults to 30 seconds. Providers must observe every supplied signal and must serialize ownership for a storage namespace. The same provider capability must remain configured whenever a capture-backed session is reopened, retired, disposed, or deleted. Capture-backed recovery and deletion fail closed without it.
+
+Workspace reversion is generic and application-defined. It does not reverse network, database, billing, or other side effects unless the provider deliberately captures them. References are normalized with `toolOutputLimits` and have an absolute 256 KiB encoded cap.
+
+| `reversionLimits` field | Default | Hard maximum |
+| --- | ---: | ---: |
+| `maxCompletedTurns` | 100 | 1000 |
+| `maxSegments` | 300 | 3000 |
+| `maxExcludedRunIds` | 1000 | 10000 |
+| `maxPendingReversionReleases` | 1000 | 10000 |
+
+Every configured value must be an integer from 1 through its hard maximum. Pruning removes complete prefixes rather than splitting an undo unit. Excluded run IDs prevent a committed branch from re-entering model context, while pending releases retain provider ownership until acknowledgement.
+
 `retireScope()` stops runtime ownership for the complete resolved storage namespace without deleting its durable snapshot. It does not load a namespace that has no cached or in-flight state. For loaded state, it preserves and waits for persistence that has already started, while later queued reads, writes, and run admissions reject with `FlexHarnessAbortError`. It cancels queued prompts and cancellable runs, rejects pending permissions, emits queue terminal events, waits for committing runs, terminal persistence, queue drains, tool-handle closure, and detached tool-provider cleanup, then purges queue status and clears and evicts the cached state. Failed cleanup ownership remains cached so a later `retireScope()` or `dispose()` call can retry it. Calls through storage-key aliases share the same retirement drain. A later call can load the durable namespace again after successful retirement if the application still resolves it.
 
 Normal retirement-induced cancellation does not make `retireScope()` reject. Unexpected failures observed through run finalization or scoped cleanup are surfaced without dropping the resources that still require cleanup. One such failure is thrown directly; multiple failures are reported through `FlexHarnessRunError`. Calling retirement or disposal again retries retained cleanup ownership.
@@ -317,7 +457,7 @@ Streaming callbacks use run-local synchronous state rather than one persistence
 
 Model resolver, tool provider, AgentSession, tool execution, tool callback, tool cleanup, and run-persistence failures cross an untrusted error boundary. By default they become a fixed immutable `FlexHarnessExternalError` before completion rejection, persistence, events, or detached-cleanup reporting. Raw external messages and aggregate members are not retained. A failed `onToolCallFinish` callback stores and accounts for only the bounded projected message; it does not otherwise reject completion, although exceeding the configured callback limits still fails the run. Scope resolution and the initial store load happen before a run exists and remain outside this boundary.
 
-`externalErrorProjector` receives one of `modelResolver`, `toolProvider`, `agentSession`, `toolExecution`, `toolCallback`, `toolCleanup`, or `persistence` as its source. It may synchronously return an application-approved plain data object `{ name, message, code? }`, limited to a 128-byte name, 2048-byte message, and optional 128-byte code. Accessors, extra keys, throwing projectors, and malformed or oversized results fall back to the fixed error. Even exported FlexHarness error subclasses thrown by external integrations are reprojected. Internally created cancellation, callback-overflow, and permission errors retain their typed behavior.
+`externalErrorProjector` receives one of `modelResolver`, `toolProvider`, `agentSession`, `toolExecution`, `toolCallback`, `toolCleanup`, `persistence`, `slashCommand`, or `turnReversion` as its source. It may synchronously return an application-approved plain data object `{ name, message, code? }`, limited to a 128-byte name, 2048-byte message, and optional 128-byte code. Accessors, extra keys, throwing projectors, and malformed or oversized results fall back to the fixed error. Even exported FlexHarness error subclasses thrown by external integrations are reprojected. Internally created cancellation, callback-overflow, and permission errors retain their typed behavior.
 
 `normalizeJsonValue()` is also exported for integrations that need the same conversion independently.
 
@@ -351,6 +491,9 @@ const unsubscribe = harness.subscribe((event) => {
     case 'run.finished':
       markRunFinished(event.runId, event.status);
       break;
+    case 'session.history.changed':
+      refreshSelectedSession(event.sessionId);
+      break;
     case 'prompt.queued':
     case 'prompt.started':
     case 'prompt.running':
@@ -363,7 +506,7 @@ const unsubscribe = harness.subscribe((event) => {
 unsubscribe();
 ```
 
-Events are discriminated, sequenced, deeply immutable snapshots. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part emits exactly one `part.completed` event before the corresponding `run.finished` event. Every `part.started`, `part.delta`, `part.updated`, and `part.completed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences. `part.updated` is cumulative metadata replacement rather than a text delta. Events contain public IDs and snapshots only; they do not expose prompt payloads, the resolved scope object, storage key, model object, provider options, or raw storage key.
+Events are discriminated, sequenced, deeply immutable snapshots. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part emits exactly one `part.completed` event before the corresponding `run.finished` event. Every `part.started`, `part.delta`, `part.updated`, and `part.completed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences. `part.updated` is cumulative metadata replacement rather than a text delta. `session.history.changed` carries `direction: 'undo' | 'redo' | 'branch'`; `runId` is present for undo and redo. Events contain public IDs and snapshots only; they do not expose prompt payloads, the resolved scope object, storage key, model object, provider options, or raw storage key.
 
 ## Stores
 
@@ -396,6 +539,8 @@ Direct store operations and non-run session mutations surface conflicts as `Flex
 
 Each domain serializes its own mutations. A successful run first persists a hidden completed projection, then finalizes the canonical Agent generation as `accepted`, then promotes the hidden projection publicly. Recovery uses the canonical generation outcome to promote an accepted stage or publish a failed/cancelled projection. Failed and cancelled generations remain auditable but never enter future model context.
 
+Projection stores accept schema version 1 or 2 from `load()`, but every `save()` receives the current schema-2 shape. A loaded schema-1 projection is treated as having no reversion segments, cursor, exclusions, pending operation, or pending releases; its next projection mutation upgrades it to schema 2. Custom stores must preserve strict compare-and-swap revisions across that read-upgrade-write cycle. Existing schema-1 messages remain visible but are not retroactively made undoable.
+
 ## Migrating From 2.x
 
 Version `3.x` replaces the single `IFlexHarnessStore` snapshot with the split stores above. Run migration while every process that can access the storage namespace is stopped.
@@ -418,11 +563,11 @@ const stores = new JsonFileFlexHarnessStores({
 await migrateLegacyFlexHarnessSnapshot(storageKey, legacySnapshot, stores);
 ```
 
-`loadLegacySnapshot()` is application-owned access to the snapshot written by the `2.x` store. The migration validates the complete source and every public run before writing. A run left streaming by a process crash is deterministically repaired to the same cancelled state that the `2.x` loader produced in memory. The migration then converts private model messages into generationless canonical Agent conversation events and records terminal SmartAgent transactions for completed, failed, and cancelled public runs. It preflights the scope, projection, permission, Agent event, and job destinations before any write, applies missing per-session domains first, and publishes scope discovery last. It is safe to rerun after no work, a completed prefix, or a complete migration when existing destination content is identical. It fails closed when a destination contains conflicting content or non-empty jobs. Keep the legacy snapshot until the migrated application has loaded and verified every storage namespace.
+`loadLegacySnapshot()` is application-owned access to the snapshot written by the `2.x` store. The migration validates the complete source and every public run before writing. A run left streaming by a process crash is deterministically repaired to the same cancelled state that the `2.x` loader produced in memory. The migration then converts private model messages into generationless canonical Agent conversation events, records terminal SmartAgent transactions for completed, failed, and cancelled public runs, and writes schema-2 projections with empty reversion state. Migrated history therefore remains visible and auditable but is not retroactively undoable; turns created after migration receive normal reversion segments and optional workspace captures. The migration preflights the scope, projection, permission, Agent event, and job destinations before any write, applies missing per-session domains first, and publishes scope discovery last. It is safe to rerun after no work, a completed prefix, or a complete migration when existing destination content is identical. It fails closed when a destination contains conflicting content or non-empty jobs. Keep the legacy snapshot until the migrated application has loaded and verified every storage namespace.
 
 ## Shutdown
 
-Model and tool resolution share the run signal. Synchronous throws are observed as resolver failures; the first failure aborts that signal and finalizes immediately without waiting for an unresponsive sibling. A detached tool provider that resolves later is observed and its handle is closed; disposal waits for that settlement and reports a late close failure.
+Model and tool resolution share the run signal. Synchronous throws are observed as resolver failures; the first failure aborts that signal and finalizes immediately without waiting for an unresponsive sibling. A detached application or resource tool provider that resolves later is observed and every acquired handle is closed; disposal waits for that settlement and reports a late close failure.
 
 Tool-handle close settles before a turn can be successful. After model generation resolves, FlexHarness stages its terminal projection before canonical acceptance; earlier execution failures are finalized as interrupted and then published from that durable outcome. Cleanup failure prevents canonical acceptance. If canonical finalization or public promotion fails, FlexHarness fences the namespace; the next load repairs public state from the durable canonical outcome and any hidden terminal stage.
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '3.5.0',
+  version: '3.7.0',
   description: 'Provider-neutral model-session runtime with durable history, permissions, typed events, and pluggable local or remote tool execution.'
 }