@modelprofile.com/flexharness 9.4.0 → 9.5.0

package/dist_ts/utils.sessionimport.js

@@ -0,0 +1,241 @@
+import { FlexHarnessValidationError } from './errors.js';
+import { FLEX_PROJECT_MANAGEMENT_LIMITS, FLEX_SESSION_IMPORT_DEFAULT_LIMITS, FLEX_SESSION_IMPORT_MAXIMUM_LIMITS, FLEX_SESSION_IMPORT_MAX_DETAILS_BYTES, FLEX_SESSION_IMPORT_MAX_MESSAGE_BYTES, } from './interfaces.js';
+import { maxSubagentNameBytes } from './utils.harnessoptions.js';
+import { assertFlexMessageRecord, assertJsonSerializable, cloneSerializable } from './utils.json.js';
+import { createBoundedTransferMessage, jsonBytes, maxTransferIdentifierBytes, requireTransferIdentifier, } from './utils.transfer.js';
+import { validateIdentifier, validateUtf8String } from './utils.validation.js';
+const maxSourceBytes = 128;
+const maxDigestBytes = 256;
+const maxImportParts = 1024;
+const controlCharacterPattern = /[\u0000-\u001f\u007f]/u;
+export function resolveSessionImportLimits(limits = {}) {
+    const resolved = {
+        maxOpenImports: limits.maxOpenImports ?? FLEX_SESSION_IMPORT_DEFAULT_LIMITS.maxOpenImports,
+        maxMessagesPerSession: limits.maxMessagesPerSession
+            ?? FLEX_SESSION_IMPORT_DEFAULT_LIMITS.maxMessagesPerSession,
+        maxSessionBytes: limits.maxSessionBytes ?? FLEX_SESSION_IMPORT_DEFAULT_LIMITS.maxSessionBytes,
+        maxPageBytes: limits.maxPageBytes ?? FLEX_SESSION_IMPORT_DEFAULT_LIMITS.maxPageBytes,
+        stagedImportIdleTimeoutMs: limits.stagedImportIdleTimeoutMs
+            ?? FLEX_SESSION_IMPORT_DEFAULT_LIMITS.stagedImportIdleTimeoutMs,
+    };
+    for (const [name, value] of Object.entries(resolved)) {
+        const maximum = FLEX_SESSION_IMPORT_MAXIMUM_LIMITS[name];
+        if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+            throw new FlexHarnessValidationError(`sessionImportLimits.${name} must be an integer from 1 through ${maximum}.`);
+        }
+    }
+    return resolved;
+}
+function requirePlainRecord(value, name) {
+    if (!value
+        || typeof value !== 'object'
+        || Array.isArray(value)
+        || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+        throw new FlexHarnessValidationError(`${name} must be a plain object.`);
+    }
+    return value;
+}
+function requireKnownKeys(record, allowedKeys, name) {
+    const unsupported = Reflect.ownKeys(record).find((key) => typeof key !== 'string' || !allowedKeys.includes(key));
+    if (unsupported !== undefined) {
+        throw new FlexHarnessValidationError(`${name} does not support "${String(unsupported)}".`);
+    }
+}
+function requireBoundedText(value, name, maxBytes) {
+    validateUtf8String(value, name, maxBytes, true);
+    if (controlCharacterPattern.test(value)) {
+        throw new FlexHarnessValidationError(`${name} must not contain control characters.`);
+    }
+    return value;
+}
+/** A timestamp exactly as `Date.prototype.toISOString()` renders it. */
+export function requireCanonicalTimestamp(value, name) {
+    if (typeof value !== 'string' || value.length > 64) {
+        throw new FlexHarnessValidationError(`${name} must be an ISO 8601 timestamp.`);
+    }
+    const time = Date.parse(value);
+    if (!Number.isFinite(time) || new Date(time).toISOString() !== value) {
+        throw new FlexHarnessValidationError(`${name} must be an ISO 8601 timestamp as Date.prototype.toISOString() renders it.`);
+    }
+    return value;
+}
+function normalizeImportPart(value) {
+    const part = requirePlainRecord(value, 'origin.part');
+    requireKnownKeys(part, ['index', 'count'], 'origin.part');
+    const { index, count } = part;
+    if (!Number.isSafeInteger(count)
+        || Number(count) < 1
+        || Number(count) > maxImportParts
+        || !Number.isSafeInteger(index)
+        || Number(index) < 0
+        || Number(index) >= Number(count)) {
+        throw new FlexHarnessValidationError(`origin.part must have a count from 1 through ${maxImportParts} and a zero-based index below it.`);
+    }
+    return { index: index, count: count };
+}
+function normalizeImportDetails(value) {
+    requirePlainRecord(value, 'origin.details');
+    try {
+        assertJsonSerializable(value, 'origin.details');
+    }
+    catch (error) {
+        throw new FlexHarnessValidationError('origin.details must be a JSON object.', { cause: error });
+    }
+    if (jsonBytes(value) > FLEX_SESSION_IMPORT_MAX_DETAILS_BYTES) {
+        throw new FlexHarnessValidationError(`origin.details must be at most ${FLEX_SESSION_IMPORT_MAX_DETAILS_BYTES} JSON bytes.`);
+    }
+    return cloneSerializable(value);
+}
+function normalizeImportSource(value) {
+    const origin = requirePlainRecord(value, 'origin');
+    requireKnownKeys(origin, ['source', 'sourceId', 'digest', 'part', 'details'], 'origin');
+    return {
+        source: requireBoundedText(origin.source, 'origin.source', maxSourceBytes),
+        sourceId: requireBoundedText(origin.sourceId, 'origin.sourceId', maxTransferIdentifierBytes),
+        digest: requireBoundedText(origin.digest, 'origin.digest', maxDigestBytes),
+        ...(origin.part === undefined ? {} : { part: normalizeImportPart(origin.part) }),
+        ...(origin.details === undefined ? {} : { details: normalizeImportDetails(origin.details) }),
+    };
+}
+function normalizeImportParent(value) {
+    const parent = requirePlainRecord(value, 'parent');
+    requireKnownKeys(parent, ['sessionId', 'runId', 'toolCallId', 'agent'], 'parent');
+    return {
+        sessionId: requireBoundedText(parent.sessionId, 'parent.sessionId', maxTransferIdentifierBytes),
+        runId: requireBoundedText(parent.runId, 'parent.runId', maxTransferIdentifierBytes),
+        toolCallId: requireBoundedText(parent.toolCallId, 'parent.toolCallId', maxTransferIdentifierBytes),
+        agent: requireBoundedText(parent.agent, 'parent.agent', maxSubagentNameBytes),
+    };
+}
+export function normalizeBeginSessionImportOptions(options) {
+    const record = requirePlainRecord(options, 'beginSessionImport options');
+    requireKnownKeys(record, ['sessionId', 'title', 'createdAt', 'updatedAt', 'origin', 'parent'], 'beginSessionImport options');
+    const sessionId = record.sessionId;
+    validateIdentifier(sessionId, 'sessionId');
+    requireTransferIdentifier(sessionId, 'sessionId');
+    if (record.title !== undefined) {
+        validateUtf8String(record.title, 'title', FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes, true);
+    }
+    const createdAt = requireCanonicalTimestamp(record.createdAt, 'createdAt');
+    const updatedAt = record.updatedAt === undefined
+        ? createdAt
+        : requireCanonicalTimestamp(record.updatedAt, 'updatedAt');
+    if (Date.parse(updatedAt) < Date.parse(createdAt)) {
+        throw new FlexHarnessValidationError('updatedAt must not be earlier than createdAt.');
+    }
+    const parent = record.parent === undefined ? undefined : normalizeImportParent(record.parent);
+    if (parent?.sessionId === sessionId) {
+        throw new FlexHarnessValidationError('An imported session cannot be its own parent.');
+    }
+    return {
+        sessionId,
+        ...(record.title === undefined ? {} : { title: record.title }),
+        createdAt,
+        updatedAt,
+        origin: normalizeImportSource(record.origin),
+        ...(parent === undefined ? {} : { parent }),
+    };
+}
+/** The identity an import is idempotent by: its source, source id and part. */
+export function sessionImportIdentity(origin) {
+    return JSON.stringify([origin.source, origin.sourceId, origin.part?.index ?? null]);
+}
+function normalizeImportedMessage(value, path, role, sessionId) {
+    try {
+        assertFlexMessageRecord(value, path);
+    }
+    catch (error) {
+        throw new FlexHarnessValidationError(`${path} is not a valid message: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    const message = cloneSerializable(value);
+    if (message.role !== role) {
+        throw new FlexHarnessValidationError(`${path}.role must be "${role}".`);
+    }
+    if (message.sessionId !== sessionId) {
+        throw new FlexHarnessValidationError(`${path}.sessionId must be the imported session "${sessionId}".`);
+    }
+    if (message.status === 'streaming') {
+        throw new FlexHarnessValidationError(`${path}.status must be completed, failed or cancelled.`);
+    }
+    requireCanonicalTimestamp(message.createdAt, `${path}.createdAt`);
+    if (message.completedAt !== undefined) {
+        requireCanonicalTimestamp(message.completedAt, `${path}.completedAt`);
+    }
+    for (const [index, part] of message.parts.entries()) {
+        if (part.type !== 'reasoning' && part.type !== 'tool')
+            continue;
+        if (part.status === 'running') {
+            throw new FlexHarnessValidationError(`${path}.parts[${index}] must not be running.`);
+        }
+    }
+    const bytes = jsonBytes(message);
+    if (bytes > FLEX_SESSION_IMPORT_MAX_MESSAGE_BYTES) {
+        throw new FlexHarnessValidationError(`${path} exceeds ${FLEX_SESSION_IMPORT_MAX_MESSAGE_BYTES} JSON bytes.`);
+    }
+    try {
+        createBoundedTransferMessage(message);
+    }
+    catch (error) {
+        throw new FlexHarnessValidationError(`${path} cannot be read back within the transfer limits.`, {
+            cause: error,
+        });
+    }
+    return { message, bytes };
+}
+/**
+ * Validates one page of imported runs. Every message must belong to `sessionId`, be terminal and
+ * fit the transfer limits; a run's user and assistant message share its run id and status.
+ */
+export function normalizeImportedRunPage(runs, sessionId, maxPageBytes) {
+    if (!Array.isArray(runs) || runs.length === 0) {
+        throw new FlexHarnessValidationError('Imported runs must be a non-empty array.');
+    }
+    let pageBytes;
+    try {
+        assertJsonSerializable(runs, 'runs');
+        pageBytes = jsonBytes(runs);
+    }
+    catch (error) {
+        throw new FlexHarnessValidationError('Imported runs must be JSON-safe.', { cause: error });
+    }
+    if (pageBytes > maxPageBytes) {
+        throw new FlexHarnessValidationError(`Imported runs exceed the page limit of ${maxPageBytes} JSON bytes.`);
+    }
+    const normalized = [];
+    let bytes = 0;
+    for (const [index, value] of runs.entries()) {
+        const path = `runs[${index}]`;
+        const run = requirePlainRecord(value, path);
+        requireKnownKeys(run, ['user', 'assistant'], path);
+        const user = normalizeImportedMessage(run.user, `${path}.user`, 'user', sessionId);
+        const assistant = normalizeImportedMessage(run.assistant, `${path}.assistant`, 'assistant', sessionId);
+        if (user.message.runId !== assistant.message.runId) {
+            throw new FlexHarnessValidationError(`${path} user and assistant messages must share one runId.`);
+        }
+        if (user.message.messageId === assistant.message.messageId) {
+            throw new FlexHarnessValidationError(`${path} user and assistant messages must have distinct ids.`);
+        }
+        if (user.message.status !== assistant.message.status) {
+            throw new FlexHarnessValidationError(`${path} user and assistant messages must share one status.`);
+        }
+        normalized.push({ user: user.message, assistant: assistant.message });
+        bytes += user.bytes + assistant.bytes;
+    }
+    return { runs: normalized, bytes };
+}
+/** Validates the shape of a handle `beginSessionImport()` returned. */
+export function validateSessionImportHandle(handle) {
+    const record = requirePlainRecord(handle, 'Session import handle');
+    requireKnownKeys(record, ['importId', 'scopeId', 'sessionId'], 'Session import handle');
+    for (const key of ['importId', 'scopeId', 'sessionId']) {
+        if (typeof record[key] !== 'string' || record[key] === '') {
+            throw new FlexHarnessValidationError(`Session import handle ${key} must be a non-empty string.`);
+        }
+    }
+    return {
+        importId: record.importId,
+        scopeId: record.scopeId,
+        sessionId: record.sessionId,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.sessionimport.js","sourceRoot":"","sources":["../ts/utils.sessionimport.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness",
-  "version": "9.4.0",
+  "version": "9.5.0",
   "type": "module",
   "description": "Managed agent sessions with tools, MCP, chat, OCR, documents and browser control through focused subpath imports.",
   "main": "./dist_ts/index.js",
@@ -62,8 +62,8 @@
     }
   },
   "dependencies": {
-    "@modelprofile.com/flexharness-agent": "9.4.0",
-    "@modelprofile.com/flexharness-models": "9.4.0",
+    "@modelprofile.com/flexharness-agent": "9.5.0",
+    "@modelprofile.com/flexharness-models": "9.5.0",
     "@push.rocks/smartrequest": "^5.0.1",
     "ai": "^7.0.107",
     "zod": "^4.4.1"

package/readme.md

@@ -235,6 +235,13 @@ const harness = new FlexHarness<IProjectScope>({
     maxExcludedRunIds: 1000,
     maxPendingReversionReleases: 1000,
   },
+  sessionImportLimits: {
+    maxOpenImports: 2,
+    maxMessagesPerSession: 2048,
+    maxSessionBytes: 64 * 1024 * 1024,
+    maxPageBytes: 1024 * 1024,
+    stagedImportIdleTimeoutMs: 5 * 60 * 1000,
+  },
   subagents: [
     {
       name: 'researcher',
@@ -805,6 +812,82 @@ Public audit history is safe to send to controllers: attachment parts contain so
 
 Sessions expose `idle`, `scheduled`, `running`, `waiting_permission`, `failed`, and `cancelled` status. Persisted non-terminal activity is repaired from canonical Agent generation outcomes after process restart; incomplete messages and parts normalize to `cancelled` unless an accepted hidden terminal stage can be promoted.
 
+## Conversation Import
+
+A finished conversation from another tool can be imported as an archived, read-only session. The import is staged in three steps, so a large conversation crosses a process boundary in bounded pages. Turning a source format into Flex messages is the importer's job; the core validates, bounds, persists and protects the result.
+
+```typescript
+const started = await harness.beginSessionImport('project:billing', {
+  sessionId: 'claude-7f3c2a',
+  title: 'Fix the billing export',
+  createdAt: '2026-09-01T09:00:00.000Z',
+  updatedAt: '2026-09-01T11:00:00.000Z',
+  origin: {
+    source: 'claude-code-transcript',
+    sourceId: '7f3c2a',
+    digest: 'sha256:9b1d…',
+    details: { cwd: '/workspace' },
+  },
+});
+
+if (started.status === 'started') {
+  try {
+    for (const page of pages) {
+      await harness.appendImportedRuns(started.handle, page);
+    }
+    const session = await harness.commitSessionImport(started.handle);
+  } finally {
+    await harness.abortSessionImport(started.handle);
+  }
+}
+```
+
+- **`beginSessionImport(scopeId, options)`** validates the options and reserves the caller-chosen `sessionId`. Choose a deterministic id, derived from the source. The result is one of three:
+  - `started`, with a handle `{ importId, scopeId, sessionId }`;
+  - `already_imported`, with the existing session;
+  - `digest_mismatch`, with the existing session.
+
+  A scope holds at most one import per `origin.source`, `origin.sourceId` and `origin.part.index`, whatever its session id. `already_imported` means that session has the same `origin.digest`, so the caller skips it. `digest_mismatch` means the source changed since; the caller deletes that session and imports again. A staged import of the same session id or source identity throws `FlexHarnessSessionBusyError`. Until the commit completes, `listSessions()` omits the session and `createSession()` refuses its id. While the import is staged, `getSession()` throws `FlexHarnessSessionBusyError`. While its commit runs, `getSession()` throws `FlexHarnessNotFoundError`, because a deletion tombstone reserves the id.
+- **`appendImportedRuns(handle, runs)`** stages one page of runs, in order. A run is `{ user, assistant }`, two messages of the exact `IFlexMessage` shape. Both belong to the imported session, share one `runId` and one terminal status (`completed`, `failed` or `cancelled`), and have no `running` reasoning or tool part. Timestamps are ISO 8601 as `Date.prototype.toISOString()` renders them. Run ids and message ids are unique within the import. A page that breaks a rule or a bound stages nothing, and the import stays open. The result reports the staged `runs`, `messages` and `bytes`.
+- **`commitSessionImport(handle)`** persists the runs and publishes the session, with one `session.created` event:
+  - `origin` is `{ kind: 'import', source, sourceId, digest, part?, details?, importedAt }`, and `archivedAt` equals `importedAt`;
+  - `createdAt` and `updatedAt` are the ones passed to `beginSessionImport()`, and the status is `idle`.
+
+  The commit first persists a deletion tombstone for the id, then writes the projection, then replaces the tombstone with the session in one scope save. A failed commit removes what it persisted through the normal tombstone cleanup. After a crash, or a save whose outcome is uncertain, the next load of the namespace resolves it: a surviving tombstone is cleaned up, and a published session is kept. A commit needs at least one run.
+- **`abortSessionImport(handle)`** discards a staged import. Nothing of it was persisted. An unknown or finished handle is ignored, so the call is safe in a `finally`. A staged import that receives no `appendImportedRuns()` call for `stagedImportIdleTimeoutMs` expires and is discarded the same way; its handle then reports `FlexHarnessNotFoundError`.
+- **Child sessions.** `parent: { sessionId, runId, toolCallId, agent }` imports a child session, such as a subagent's conversation. The parent must be a committed imported session in the same scope. Its assistant message of `runId` must hold the tool call `toolCallId` whose `childSessionId` names the child. No other session may claim that tool call. The child gets `depth` one below its parent, at most `FLEX_SESSION_IMPORT_MAX_DEPTH` (8). Deleting the parent deletes its children.
+
+**Read-only.** An imported session never runs, and nothing writes model context for it: it has no Agent events and no tool jobs. Every operation that would change its history or model context throws `FlexHarnessImportedSessionError` (code `FLEX_SESSION_READ_ONLY`):
+
+- `prompt`, `startPrompt`, `enqueuePrompt` and `schedulePrompt`;
+- `executeSlashCommand` and `compactSession`;
+- `undoSession` and `redoSession`;
+- `pushRuntimeEvent`, `reconcileToolExecution` and `archiveSessionEvents`;
+- the project-management writes: tasks, goal and scratchpad.
+
+`listSlashCommands()` reports every command unavailable with the reason `Session is an imported conversation and is read-only.` Reads work: sessions, messages, message pages, reversion info and project state. So do `updateSession()` (title and archived flag), `deleteSession()` and `deleteSessionGenerationCohort()`. A load never repairs an imported session's runs from Agent generation outcomes, because it has none.
+
+**Bounds.** `sessionImportLimits` sets the bounds; each must be an integer from 1 through its maximum:
+
+| Limit | Default | Maximum |
+|---|---|---|
+| `maxOpenImports` (staged imports at once, per harness) | 2 | 64 |
+| `maxMessagesPerSession` | 2048 | 20000 |
+| `maxSessionBytes` (JSON bytes of all messages) | 64 MiB | 256 MiB |
+| `maxPageBytes` (JSON bytes of one `appendImportedRuns()` page) | 1 MiB | 1.5 MiB |
+| `stagedImportIdleTimeoutMs` (idle time before a staged import expires) | 5 minutes | 1 hour |
+
+Some bounds are fixed:
+
+- one message is at most `FLEX_SESSION_IMPORT_MAX_MESSAGE_BYTES` (480 KiB), and must read back through the message transfer limits;
+- `origin.details` is a JSON object of at most `FLEX_SESSION_IMPORT_MAX_DETAILS_BYTES` (16 KiB);
+- `origin.source` is at most 128 UTF-8 bytes, `origin.sourceId` 512 and `origin.digest` 256, none with control characters;
+- `origin.part` has a `count` from 1 through 1024 and a zero-based `index` below it.
+
+Staged runs are held in memory until the commit, so the memory of open imports is bounded by `maxOpenImports` × `maxSessionBytes`. Retiring the scope, disposing the harness or the idle expiry discards staged imports. The expiry timer does not keep the process alive.
+
+**Stores.** The import adds no store method. Scope snapshots carry the optional session `origin`, and a store that validates session keys exactly must accept it. The commit writes the whole projection in one save at revision 1. FlexHarness versions before 9.5.0 reject the new key under their strict reader, so a downgrade over imported sessions is unsupported.
+
 ## Permissions
 
 Tools request permission through the run-scoped provider context:

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '9.4.0',
+  version: '9.5.0',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }