@aiwg/cli 2026.8.0 → 2026.8.1

package/dist/src/serve/fleet-mission-conductor.js

@@ -0,0 +1,293 @@
+/**
+ * Fleet Mission Conductor — management-plane orchestration over N executor
+ * targets using the neutral fleet-workload/v1 vocabulary.
+ *
+ * AIWG owns parent fan-out, aggregation, audit, and completion. Execution
+ * substrates (Agentic Sandbox first, other adapters later) own target-local
+ * lifecycle and report revisioned observations through the RunFleetWorker seam.
+ *
+ * @implements #1991
+ */
+import { routeMission } from './agent-router.js';
+import { StackAdapterRegistry } from './stack-adapters.js';
+const terminalFailures = new Set(['failed', 'cancelled', 'timed-out']);
+const reviewStates = new Set(['unknown', 'operator-review-required']);
+function lifecycleSatisfied(kind, state, health) {
+    switch (kind) {
+        case 'one-shot-command': return state === 'succeeded';
+        case 'persistent-agent': return state === 'retained' || state === 'detached' || state === 'running';
+        case 'daemon': return (state === 'healthy' || state === 'running') && health === 'healthy';
+        case 'scheduled-collector': return state === 'scheduled' || state === 'succeeded';
+    }
+}
+function collapseEvents(events) {
+    let latest;
+    const stale = [];
+    const artifacts = new Map();
+    for (const event of events) {
+        if (latest && event.revision <= latest.revision) {
+            stale.push(event.revision);
+            continue;
+        }
+        latest = event;
+        for (const artifact of event.artifacts ?? [])
+            artifacts.set(`${artifact.kind}:${artifact.uri}`, artifact);
+    }
+    return { latest, stale, artifacts: [...artifacts.values()] };
+}
+function emptyAggregation(policy) {
+    return {
+        policy,
+        successful: 0,
+        failed: 0,
+        pending: 0,
+        reviewRequired: 0,
+        evidenceMissing: [],
+        completionEligible: false,
+        reason: 'children have not been evaluated',
+    };
+}
+function aggregate(policy, cycles) {
+    const successful = cycles.filter((cycle) => cycle.satisfied).length;
+    const failed = cycles.filter((cycle) => terminalFailures.has(cycle.observedState)).length;
+    const reviewRequired = cycles.filter((cycle) => reviewStates.has(cycle.observedState)).length;
+    const pending = cycles.length - successful - failed - reviewRequired;
+    const evidenceMissing = cycles.filter((cycle) => !cycle.evidenceComplete).map((cycle) => cycle.cycleId);
+    const allEvidence = evidenceMissing.length === 0;
+    let policySatisfied = false;
+    let reason = '';
+    switch (policy.mode) {
+        case 'all-pass':
+            policySatisfied = cycles.length > 0 && successful === cycles.length;
+            reason = `${successful}/${cycles.length} children satisfied all-pass`;
+            break;
+        case 'quorum':
+            policySatisfied = successful >= policy.minimumSuccesses;
+            reason = `${successful}/${policy.minimumSuccesses} quorum successes`;
+            break;
+        case 'best-output':
+            policySatisfied = cycles.some((cycle) => cycle.satisfied && Boolean(cycle.output));
+            reason = policySatisfied ? 'at least one satisfied child produced output' : 'no satisfied child produced output';
+            break;
+        case 'fail-fast':
+            policySatisfied = failed === 0 && cycles.length > 0 && successful === cycles.length;
+            reason = failed > 0 ? 'a child reached a terminal failure' : `${successful}/${cycles.length} children satisfied`;
+            break;
+        case 'manual-review':
+            policySatisfied = false;
+            reason = 'manual-review policy requires an audited operator decision';
+            break;
+    }
+    if (reviewRequired > 0)
+        reason = `${reviewRequired} child observation(s) require operator review`;
+    if (!allEvidence)
+        reason = `required evidence missing for: ${evidenceMissing.join(', ')}`;
+    return {
+        policy,
+        successful,
+        failed,
+        pending,
+        reviewRequired,
+        evidenceMissing,
+        completionEligible: policySatisfied && allEvidence && reviewRequired === 0,
+        reason,
+    };
+}
+function cloneLedger(ledger) {
+    return structuredClone(ledger);
+}
+/**
+ * Runs every newly admitted child concurrently. Target allocation happens
+ * before execution, so one slow child cannot serialize unrelated work.
+ */
+export class FleetMissionConductor {
+    adapters;
+    runWorker;
+    scoreOutput;
+    ledgerStore;
+    /** Prevent concurrent child completions from committing snapshots out of order. */
+    persistQueue = Promise.resolve();
+    constructor(options) {
+        this.adapters = options.adapters ?? new StackAdapterRegistry();
+        this.runWorker = options.runWorker;
+        this.scoreOutput = options.scoreOutput ?? ((result) => result.output?.length ?? 0);
+        this.ledgerStore = options.ledgerStore;
+    }
+    async conduct(plan, pool, resumeFrom) {
+        const priorById = new Map((resumeFrom?.cycles ?? []).map((cycle) => [cycle.cycleId, cycle]));
+        const ledger = {
+            missionId: plan.missionId,
+            goal: plan.goal,
+            completionCriterion: plan.completionCriterion,
+            activityLog: [`mission ${plan.missionId} fleet start — ${plan.cycles.length} child workload(s)`],
+            cycles: [],
+            totalCost: 0,
+            checkpoint: { completed: [], pending: plan.cycles.map((cycle) => cycle.id), failed: [] },
+            runtimesUsed: [],
+            parentState: 'running',
+            aggregation: emptyAggregation(plan.aggregation),
+        };
+        const admitted = [];
+        const usedExecutors = new Set();
+        for (const cycle of plan.cycles) {
+            const prior = priorById.get(cycle.id);
+            if (prior?.satisfied && prior.evidenceComplete && !reviewStates.has(prior.observedState)) {
+                ledger.cycles.push(prior);
+                ledger.activityLog.push(`child ${cycle.id} re-adopted from durable completed state`);
+                continue;
+            }
+            const adapter = this.adapters.get(cycle.runtime);
+            if (!adapter) {
+                ledger.cycles.push(this.unroutable(cycle, `no stack adapter registered for runtime '${cycle.runtime}'`));
+                continue;
+            }
+            let candidates = pool;
+            if (cycle.targetId)
+                candidates = candidates.filter((executor) => executor.executorId === cycle.targetId);
+            if (plan.requireDistinctTargets !== false) {
+                candidates = candidates.filter((executor) => !usedExecutors.has(executor.executorId));
+            }
+            const routing = routeMission(candidates, {
+                capabilities: [adapter.runtimeCapability, ...(cycle.requiredCapabilities ?? [])],
+            }, cycle.longRunning ?? false);
+            if (!routing.selected) {
+                ledger.cycles.push(this.unroutable(cycle, 'no distinct connected executor satisfies the child requirements'));
+                continue;
+            }
+            const executor = routing.selected.executor;
+            usedExecutors.add(executor.executorId);
+            const dispatchId = cycle.dispatchId ?? `${plan.missionId}:${cycle.id}:dispatch`;
+            const lineage = {
+                orchestratorId: plan.orchestratorId,
+                missionId: plan.missionId,
+                dispatchId,
+                idempotencyKey: cycle.idempotencyKey ?? dispatchId,
+                parentId: plan.missionId,
+                childId: cycle.id,
+                targetId: cycle.targetId ?? executor.executorId,
+                executorId: executor.executorId,
+                runtimeId: cycle.runtime,
+            };
+            admitted.push({ cycle, executor, invocation: adapter.invoke(cycle.prompt), lineage });
+            ledger.activityLog.push(`child ${cycle.id} admitted on target ${lineage.targetId} as ${cycle.workloadKind}`);
+        }
+        ledger.aggregation = aggregate(plan.aggregation, ledger.cycles);
+        await this.persist(ledger);
+        await Promise.all(admitted.map(async ({ cycle, executor, invocation, lineage }) => {
+            let result;
+            try {
+                const ran = await this.runWorker(cycle, executor, invocation, lineage);
+                const collapsed = collapseEvents(ran.events);
+                const latest = collapsed.latest;
+                const observedState = latest?.observedState ?? 'unknown';
+                const artifacts = collapsed.artifacts;
+                const required = cycle.requiredEvidence ?? [];
+                const evidenceComplete = required.every((kind) => artifacts.some((artifact) => artifact.kind === kind));
+                result = {
+                    cycleId: cycle.id,
+                    runtime: cycle.runtime,
+                    primitive: invocation.primitive,
+                    executorId: executor.executorId,
+                    routed: true,
+                    reason: latest ? `observed revision ${latest.revision}: ${observedState}` : 'runtime returned no lifecycle event',
+                    output: ran.output,
+                    cost: ran.cost ?? 0,
+                    workloadKind: cycle.workloadKind,
+                    lineage,
+                    commandId: ran.commandId ?? latest?.commandId,
+                    taskId: latest?.taskId,
+                    sessionId: ran.sessionId ?? latest?.sessionId,
+                    observedState,
+                    revision: latest?.revision ?? 0,
+                    lastSeen: latest?.lastSeen,
+                    health: latest?.health,
+                    backpressure: latest?.backpressure,
+                    artifacts,
+                    staleEventRevisions: collapsed.stale,
+                    evidenceComplete,
+                    satisfied: evidenceComplete && lifecycleSatisfied(cycle.workloadKind, observedState, latest?.health),
+                };
+            }
+            catch (error) {
+                result = {
+                    cycleId: cycle.id,
+                    runtime: cycle.runtime,
+                    primitive: invocation.primitive,
+                    executorId: executor.executorId,
+                    routed: true,
+                    reason: `worker error: ${error instanceof Error ? error.message : String(error)}`,
+                    cost: 0,
+                    workloadKind: cycle.workloadKind,
+                    lineage,
+                    observedState: 'unknown',
+                    revision: 0,
+                    artifacts: [],
+                    staleEventRevisions: [],
+                    evidenceComplete: (cycle.requiredEvidence ?? []).length === 0,
+                    satisfied: false,
+                };
+            }
+            ledger.cycles.push(result);
+            ledger.activityLog.push(`child ${cycle.id} observed ${result.observedState} at revision ${result.revision}`);
+            ledger.aggregation = aggregate(plan.aggregation, ledger.cycles);
+            await this.persist(ledger);
+        }));
+        // Stable plan order makes durable snapshots and UI projection deterministic.
+        const order = new Map(plan.cycles.map((cycle, index) => [cycle.id, index]));
+        ledger.cycles.sort((a, b) => (order.get(a.cycleId) ?? 0) - (order.get(b.cycleId) ?? 0));
+        ledger.totalCost = ledger.cycles.reduce((sum, cycle) => sum + cycle.cost, 0);
+        ledger.runtimesUsed = [...new Set(ledger.cycles.filter((cycle) => cycle.routed).map((cycle) => cycle.runtime))];
+        ledger.checkpoint = {
+            completed: ledger.cycles.filter((cycle) => cycle.satisfied).map((cycle) => cycle.cycleId),
+            failed: ledger.cycles.filter((cycle) => terminalFailures.has(cycle.observedState)).map((cycle) => cycle.cycleId),
+            pending: ledger.cycles.filter((cycle) => !cycle.satisfied && !terminalFailures.has(cycle.observedState)).map((cycle) => cycle.cycleId),
+        };
+        let best;
+        for (const cycle of ledger.cycles) {
+            if (!cycle.output || !cycle.satisfied)
+                continue;
+            const score = this.scoreOutput(cycle);
+            if (!best || score > best.score)
+                best = { cycleId: cycle.cycleId, runtime: cycle.runtime, output: cycle.output, score };
+        }
+        ledger.bestOutput = best;
+        ledger.aggregation = aggregate(plan.aggregation, ledger.cycles);
+        ledger.parentState = ledger.aggregation.completionEligible
+            ? 'completed'
+            : ledger.aggregation.reviewRequired > 0 || plan.aggregation.mode === 'manual-review'
+                ? 'operator-review-required'
+                : ledger.aggregation.failed > 0
+                    ? 'failed'
+                    : 'pending';
+        ledger.activityLog.push(`mission ${plan.missionId} fleet end — ${ledger.parentState}: ${ledger.aggregation.reason}`);
+        await this.persist(ledger);
+        return ledger;
+    }
+    unroutable(cycle, reason) {
+        return {
+            cycleId: cycle.id,
+            runtime: cycle.runtime,
+            primitive: '(none)',
+            routed: false,
+            reason,
+            cost: 0,
+            workloadKind: cycle.workloadKind,
+            observedState: 'operator-review-required',
+            revision: 0,
+            artifacts: [],
+            staleEventRevisions: [],
+            evidenceComplete: (cycle.requiredEvidence ?? []).length === 0,
+            satisfied: false,
+        };
+    }
+    async persist(ledger) {
+        if (!this.ledgerStore)
+            return;
+        const snapshot = cloneLedger(ledger);
+        this.persistQueue = this.persistQueue.then(async () => {
+            await this.ledgerStore.save(snapshot);
+        });
+        await this.persistQueue;
+    }
+}
+//# sourceMappingURL=fleet-mission-conductor.js.map

package/dist/src/sessions/index.js

@@ -9,6 +9,7 @@ export * from './optional-backends.js';
 export * from './knowledge-shard.js';
 export * from './candidates.js';
 export * from './promotion.js';
+export * from './output-registration.js';
 export * from './importer.js';
 export * from './import-lease.js';
 export * from './batch-contracts.js';

package/dist/src/sessions/output-registration.js

@@ -0,0 +1,338 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { dirname, relative, resolve, sep } from 'node:path';
+import { z } from 'zod';
+import { SessionContractError, sha256 } from './contracts.js';
+const DigestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const ReferenceSchema = z.string().min(1).max(512).refine(value => !/[\r\n\0]/.test(value), 'references must be single-line inert locators');
+export const OutputSourceReferenceSchema = z.object({
+    kind: z.enum(['file', 'url', 'note', 'session', 'artifact', 'context-pack']),
+    ref: ReferenceSchema,
+    digest: DigestSchema.nullable().default(null),
+    span: z.object({
+        start: z.number().int().nonnegative(),
+        end: z.number().int().positive(),
+        quoteDigest: DigestSchema,
+    }).strict().nullable().default(null),
+}).strict().superRefine((value, context) => {
+    if (value.span && value.span.end <= value.span.start) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: 'source span end must exceed start' });
+    }
+});
+export const OutputRegistrationRequestSchema = z.object({
+    outputPath: z.string().min(1),
+    mediaType: z.string().min(1).max(128),
+    contextPack: z.object({
+        id: ReferenceSchema,
+        digest: DigestSchema,
+        sources: z.array(OutputSourceReferenceSchema).min(1).max(256),
+    }).strict(),
+    supersedes: z.array(ReferenceSchema).max(128).default([]),
+    conflictsWith: z.array(ReferenceSchema).max(128).default([]),
+}).strict();
+/**
+ * Minimal incremental index sink. Each registration is independently atomic,
+ * discoverable, and replay-safe; corpus-wide index builders can consume these
+ * bounded records without rescanning output bodies.
+ */
+export class FilesystemDerivedOutputIndex {
+    root;
+    constructor(projectRoot) {
+        this.root = resolve(projectRoot, '.aiwg/memory/output-registration/index');
+        assertStorageRootInsideProject(projectRoot, this.root);
+    }
+    register(registration) {
+        if (!/^sha256:[0-9a-f]{64}$/.test(registration.registrationId)) {
+            throw new Error('invalid output registration identity');
+        }
+        const filePath = resolve(this.root, `${registration.registrationId.replace(':', '_')}.json`);
+        const existing = readJsonIfPresent(filePath);
+        if (existing) {
+            if (JSON.stringify(existing) !== JSON.stringify(registration)) {
+                throw new SessionContractError('IMPORT_CONFLICT', 'derived output index identity already has different content');
+            }
+            return;
+        }
+        writeJsonAtomic(filePath, registration);
+    }
+    registrations() {
+        if (!existsSync(this.root))
+            return [];
+        return readdirSync(this.root)
+            .filter(name => /^sha256_[0-9a-f]{64}\.json$/.test(name))
+            .sort()
+            .map(name => JSON.parse(readFileSync(resolve(this.root, name), 'utf8')));
+    }
+}
+function canonicalReference(value) {
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol === 'http:' || parsed.protocol === 'https:') {
+            parsed.username = '';
+            parsed.password = '';
+            parsed.search = '';
+            parsed.hash = '';
+            return parsed.toString();
+        }
+    }
+    catch {
+        // Non-URL references are opaque inert identifiers.
+    }
+    return value;
+}
+function assertStorageRootInsideProject(projectRoot, storageRoot) {
+    const root = realpathSync(projectRoot);
+    const candidate = resolve(projectRoot, storageRoot);
+    if (candidate !== resolve(projectRoot) && !candidate.startsWith(`${resolve(projectRoot)}${sep}`)) {
+        throw new SessionContractError('SOURCE_OUTSIDE_ALLOWED_ROOT', 'memory storage must be inside the project');
+    }
+    let ancestor = candidate;
+    while (!existsSync(ancestor)) {
+        const parent = dirname(ancestor);
+        if (parent === ancestor)
+            break;
+        ancestor = parent;
+    }
+    const actualAncestor = realpathSync(ancestor);
+    if (actualAncestor !== root && !actualAncestor.startsWith(`${root}${sep}`)) {
+        throw new SessionContractError('SOURCE_OUTSIDE_ALLOWED_ROOT', 'memory storage cannot traverse a link outside the project');
+    }
+}
+function assertNoSecretMaterial(value, field) {
+    const secretAssignment = /(?:^|[?&;:\s])(?:api[_-]?key|access[_-]?token|token|secret|password|passwd|authorization)\s*[:=]\s*[^\s&;]+/i;
+    const privateKey = /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/;
+    const providerToken = /(?:^|[^a-z0-9])(?:ghp|github_pat|sk|xox[baprs])_[a-z0-9_-]{16,}/i;
+    if (secretAssignment.test(value) || privateKey.test(value) || providerToken.test(value)) {
+        throw new SessionContractError('SOURCE_NOT_AUTHORIZED', `${field} appears to contain secret material; store only a non-secret locator`);
+    }
+}
+function canonicalRequest(request) {
+    const canonical = {
+        ...request,
+        contextPack: {
+            ...request.contextPack,
+            id: canonicalReference(request.contextPack.id),
+            sources: request.contextPack.sources.map(source => ({
+                ...source,
+                ref: canonicalReference(source.ref),
+            })),
+        },
+        supersedes: [...new Set(request.supersedes.map(canonicalReference))].sort(),
+        conflictsWith: [...new Set(request.conflictsWith.map(canonicalReference))].sort(),
+    };
+    assertNoSecretMaterial(canonical.contextPack.id, 'context-pack identity');
+    for (const source of canonical.contextPack.sources) {
+        assertNoSecretMaterial(source.ref, 'source reference');
+    }
+    for (const value of [...canonical.supersedes, ...canonical.conflictsWith]) {
+        assertNoSecretMaterial(value, 'lifecycle reference');
+    }
+    return canonical;
+}
+function resolveImmutableOutput(projectRoot, requestedPath) {
+    if (requestedPath.includes('\0')) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'output path contains a null byte');
+    }
+    const pathSegments = requestedPath.toLocaleLowerCase().split(/[\\/]+/);
+    if (pathSegments.some(segment => segment === '.env'
+        || segment === '.ssh'
+        || /^(?:credentials?|secrets?|tokens?)(?:\.|$)/.test(segment))) {
+        throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'sensitive credential/secret paths cannot be registered as ordinary outputs');
+    }
+    const root = realpathSync(projectRoot);
+    const candidate = realpathSync(resolve(root, requestedPath));
+    if (candidate !== root && !candidate.startsWith(`${root}${sep}`)) {
+        throw new SessionContractError('SOURCE_OUTSIDE_ALLOWED_ROOT', 'registered output must resolve inside the project');
+    }
+    return { absolute: candidate, locator: relative(root, candidate).split(sep).join('/') };
+}
+function registrationFor(projectRoot, raw) {
+    const request = canonicalRequest(OutputRegistrationRequestSchema.parse(raw));
+    const output = resolveImmutableOutput(projectRoot, request.outputPath);
+    const content = readFileSync(output.absolute);
+    const digest = `sha256:${createHash('sha256').update(content).digest('hex')}`;
+    const identity = {
+        output: { locator: output.locator, mediaType: request.mediaType, digest, byteLength: content.length },
+        contextPack: request.contextPack,
+        supersedes: request.supersedes,
+        conflictsWith: request.conflictsWith,
+    };
+    return {
+        schemaVersion: 'aiwg.output-registration.v1',
+        registrationId: sha256(JSON.stringify(identity)),
+        ...identity,
+    };
+}
+export class FilesystemOutputRegistrationStore {
+    root;
+    outboxRoot;
+    receiptRoot;
+    constructor(projectRoot) {
+        this.root = resolve(projectRoot, '.aiwg/memory/output-registration');
+        assertStorageRootInsideProject(projectRoot, this.root);
+        this.outboxRoot = resolve(this.root, 'outbox');
+        this.receiptRoot = resolve(this.root, 'receipts');
+    }
+    getReceipt(registrationId) {
+        return readJsonIfPresent(this.receiptPath(registrationId));
+    }
+    begin(operationId, registration) {
+        const existing = readJsonIfPresent(this.outboxPath(registration.registrationId));
+        if (existing)
+            return existing;
+        const record = {
+            schemaVersion: 'aiwg.output-registration-outbox.v1',
+            operationId,
+            registration,
+            state: 'pending',
+            attempts: 0,
+            lastError: null,
+            updatedAt: new Date().toISOString(),
+        };
+        writeJsonAtomic(this.outboxPath(registration.registrationId), record);
+        return record;
+    }
+    fail(registrationId, message) {
+        const path = this.outboxPath(registrationId);
+        const record = readJsonIfPresent(path);
+        if (!record)
+            throw new Error(`missing output-registration outbox record: ${registrationId}`);
+        const failed = {
+            ...record,
+            attempts: record.attempts + 1,
+            lastError: message.slice(0, 512),
+            updatedAt: new Date().toISOString(),
+        };
+        writeJsonAtomic(path, failed);
+        return failed;
+    }
+    complete(operationId, registration) {
+        const existing = this.getReceipt(registration.registrationId);
+        if (existing) {
+            unlinkIfPresent(this.outboxPath(registration.registrationId));
+            return { ...existing, duplicate: true };
+        }
+        const receipt = {
+            schemaVersion: 'aiwg.output-registration-receipt.v1',
+            receiptId: sha256(`${operationId}\0${registration.registrationId}`),
+            registrationId: registration.registrationId,
+            operationId,
+            outputLocator: registration.output.locator,
+            outputDigest: registration.output.digest,
+            contextPackId: registration.contextPack.id,
+            contextPackDigest: registration.contextPack.digest,
+            sourceRefs: registration.contextPack.sources.map(source => source.ref),
+            registeredAt: new Date().toISOString(),
+            duplicate: false,
+        };
+        writeJsonAtomic(this.receiptPath(registration.registrationId), receipt);
+        unlinkIfPresent(this.outboxPath(registration.registrationId));
+        return receipt;
+    }
+    pending() {
+        if (!existsSync(this.outboxRoot))
+            return [];
+        return readdirSync(this.outboxRoot)
+            .filter(name => /^sha256_[0-9a-f]{64}\.json$/.test(name))
+            .sort()
+            .map(name => JSON.parse(readFileSync(resolve(this.outboxRoot, name), 'utf8')));
+    }
+    safeName(registrationId) {
+        if (!/^sha256:[0-9a-f]{64}$/.test(registrationId)) {
+            throw new Error('invalid output registration identity');
+        }
+        return `${registrationId.replace(':', '_')}.json`;
+    }
+    outboxPath(registrationId) {
+        return resolve(this.outboxRoot, this.safeName(registrationId));
+    }
+    receiptPath(registrationId) {
+        return resolve(this.receiptRoot, this.safeName(registrationId));
+    }
+}
+export class OutputRegistrationCoordinator {
+    store;
+    index;
+    projectRoot;
+    constructor(projectRoot, store, index) {
+        this.store = store;
+        this.index = index;
+        this.projectRoot = resolve(projectRoot);
+    }
+    preview(request) {
+        const registration = registrationFor(this.projectRoot, request);
+        const operationId = sha256(JSON.stringify({
+            registrationId: registration.registrationId,
+            outputDigest: registration.output.digest,
+            contextPackDigest: registration.contextPack.digest,
+        }));
+        return {
+            ...registration,
+            operationId,
+            duplicate: Boolean(this.store.getReceipt(registration.registrationId)),
+            confirmationRequired: true,
+        };
+    }
+    async register(input) {
+        const preview = this.preview(input.request);
+        if (preview.operationId !== input.operationId) {
+            throw new SessionContractError('OPERATION_NOT_AUTHORIZED', 'output registration requires confirmation of the exact current preview');
+        }
+        const existing = this.store.getReceipt(preview.registrationId);
+        if (existing)
+            return { ...existing, duplicate: true };
+        const registration = registrationFor(this.projectRoot, input.request);
+        if (registration.registrationId !== preview.registrationId
+            || registration.output.digest !== preview.output.digest) {
+            throw new SessionContractError('IMPORT_CONFLICT', 'output changed after registration preview');
+        }
+        this.store.begin(input.operationId, registration);
+        try {
+            await this.index.register(registration);
+        }
+        catch (error) {
+            this.store.fail(registration.registrationId, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        return this.store.complete(input.operationId, registration);
+    }
+    async replayPending() {
+        const receipts = [];
+        for (const record of this.store.pending()) {
+            try {
+                await this.index.register(record.registration);
+                receipts.push(this.store.complete(record.operationId, record.registration));
+            }
+            catch (error) {
+                this.store.fail(record.registration.registrationId, error instanceof Error ? error.message : String(error));
+            }
+        }
+        return receipts;
+    }
+}
+function readJsonIfPresent(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function writeJsonAtomic(filePath, value) {
+    mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
+    const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temporary, filePath);
+}
+function unlinkIfPresent(filePath) {
+    try {
+        unlinkSync(filePath);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+//# sourceMappingURL=output-registration.js.map