@sema-agent/core 5.12.0 → 5.14.0

package/dist/core/retention.d.ts

@@ -0,0 +1,36 @@
+export type RetentionDeclaration = "managed" | "none";
+export interface RetentionDeclaring {
+    readonly retention?: RetentionDeclaration;
+}
+export interface RetentionPolicy {
+    maxAgeDays: number;
+}
+export interface ManagedRetentionCapability {
+    listRetentionDomains(): Promise<readonly string[]>;
+    expireCheckpoints(input: {
+        domain: string;
+        cutoffMs: number;
+    }): Promise<RetentionReceipt>;
+    deleteExpiredSessions(input: {
+        domain: string;
+        cutoffMs: number;
+    }): Promise<RetentionReceipt>;
+    deleteOrphanToolResults(input: {
+        domain: string;
+        cutoffMs: number;
+    }): Promise<RetentionReceipt>;
+}
+export interface RetentionReceipt {
+    domain: string;
+    deleted: number;
+    skipped: number;
+    tombstones: number;
+}
+export declare function assertRetentionCapability(input: {
+    policy: RetentionPolicy | undefined;
+    locked: boolean;
+    stores: ReadonlyArray<{
+        name: string;
+        store: object | undefined;
+    }>;
+}): void;

package/dist/core/retention.js

@@ -0,0 +1,31 @@
+function codedError(code, message) {
+    const e = new Error(message);
+    e.code = code;
+    return e;
+}
+export function assertRetentionCapability(input) {
+    const { policy, locked, stores } = input;
+    if (policy !== undefined && (!Number.isFinite(policy.maxAgeDays) || policy.maxAgeDays < 0)) {
+        throw codedError("config.retention_policy", `retentionPolicy.maxAgeDays must be a finite non-negative number of days (got ${String(policy.maxAgeDays)}).`);
+    }
+    const declaredRetention = (name, store) => {
+        const r = store.retention;
+        if (r === undefined || r === "none")
+            return "none";
+        if (r === "managed")
+            return "managed";
+        throw codedError("config.retention_capability", `store "${name}" declares an unparseable retention value ${JSON.stringify(r)} — expected "managed" or "none".`);
+    };
+    const declarations = stores
+        .filter((s) => s.store !== undefined)
+        .map(({ name, store }) => ({ name, retention: declaredRetention(name, store) }));
+    if (!locked || policy === undefined)
+        return;
+    const incapable = declarations.filter(({ retention }) => retention !== "managed");
+    if (incapable.length > 0) {
+        throw codedError("config.retention_capability", `retention policy is LOCKED but ${incapable.map((s) => s.name).join(", ")} ` +
+            `declare${incapable.length === 1 ? "s" : ""} retention "none" (or no declaration — read fail-closed as "none"): ` +
+            `a locked retention policy over stores that cannot delete would be "policy locked, data immortal". ` +
+            `Wire managed-retention stores, or unlock/remove the retention policy.`);
+    }
+}

package/dist/core/runner/assemble-result.d.ts

@@ -58,6 +58,7 @@ export interface ResultFlags {
     model?: string;
     unpricedSpend?: boolean;
     rewindNotes?: TaskResult["rewindNotes"];
+    strandedHumanAnswers?: TaskResult["strandedHumanAnswers"];
     remoteEnvFailures?: TaskResult["remoteEnvFailures"];
     retryAfterMs?: number;
     abortedForTimeout: boolean;

package/dist/core/runner/assemble-result.js

@@ -154,10 +154,10 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     if (errorCode !== undefined && SALVAGE_ELIGIBLE_TERMINALS.has(errorCode)) {
         salvagedOutput = text.trim() || undefined;
     }
-    const retryAfterMs = errorCode === "usage.window_exhausted" ? flags.retryAfterMs : undefined;
+    const retryAfterMs = errorCode === "usage.window_exhausted" || errorCode === "memory.admission_required" ? flags.retryAfterMs : undefined;
     const { compactionMicroUsd: _internalCompaction, ...publicStats } = stats;
     void _internalCompaction;
     if (flags.unpricedSpend)
         delete publicStats.costMicroUsd;
-    return { taskId, sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), checkpointToken, checkpointGate, ...(workspaceRestoreMode !== undefined ? { workspaceRestoreMode } : {}), ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), ...(flags.remoteEnvFailures !== undefined && flags.remoteEnvFailures.length > 0 ? { remoteEnvFailures: flags.remoteEnvFailures } : {}), stats: publicStats };
+    return { taskId, sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), checkpointToken, checkpointGate, ...(workspaceRestoreMode !== undefined ? { workspaceRestoreMode } : {}), ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), ...(flags.remoteEnvFailures !== undefined && flags.remoteEnvFailures.length > 0 ? { remoteEnvFailures: flags.remoteEnvFailures } : {}), ...(flags.strandedHumanAnswers !== undefined && flags.strandedHumanAnswers.length > 0 ? { strandedHumanAnswers: flags.strandedHumanAnswers } : {}), stats: publicStats };
 }

package/dist/core/runner/prepare-memory.d.ts

@@ -8,6 +8,13 @@ export interface PrepareMemoryInput {
     memoryWriteGateRef: {
         current?: BeforeWriteHook;
     };
+    admissionCtx: {
+        orgMemoryDenied: boolean;
+        complianceDegraded: boolean;
+        parentAdmittedOrgScopes: readonly string[] | undefined;
+        priorOwnVerdict: import("../memory-admission.js").OwnOrgAdmissionVerdict | undefined;
+        governedProvenance: boolean;
+    };
 }
 export interface PrepareMemoryResult {
     memoryEngineSession: Prepared["memoryEngineSession"];
@@ -16,5 +23,7 @@ export interface PrepareMemoryResult {
         path: string;
         content: string;
     }>;
+    admittedOrgScopes: readonly string[];
+    ownOrgVerdict: import("../memory-admission.js").OwnOrgAdmissionVerdict | undefined;
 }
 export declare function prepareMemory(input: PrepareMemoryInput): Promise<PrepareMemoryResult>;

package/dist/core/runner/prepare-memory.js

@@ -1,3 +1,4 @@
+import { admitMemoryScopes } from "../memory-admission.js";
 import { adoptLegacyRepoDirs, deriveRepoControlPlaneDir, deriveProjectControlDir, deriveProjectMemoryDir, deriveRepoMemoryDir, drainMemoryAnnouncements, enqueueMemoryAnnouncement, lookupProjectIdHint, recordProjectIdHint, resolveMemoryEngineRoot } from "../memory-engine/layout.js";
 import { classifyScopePlanes, derivePersonalControlDir, derivePersonalMemoryDir, mergeHarvestReports, mergeInjections, needsDualRoots, parsedProjectPlane } from "../memory-engine/dual-root.js";
 import { normalizeMemorySpec } from "../memory.js";
@@ -5,8 +6,33 @@ import { MemoryEngine } from "../memory-engine/engine.js";
 import { assertScopeContractPlacement, parseScopeKey, resolveProjectId } from "../memory-engine/scope-contract.js";
 import { FileMemoryEngineBackend } from "../memory-engine/file-backend.js";
 export async function prepareMemory(input) {
-    const { spec, deps, sessionId, taskRootPath, memoryWriteGateRef } = input;
+    const { spec, deps, sessionId, taskRootPath, memoryWriteGateRef, admissionCtx } = input;
     const memorySpec = normalizeMemorySpec(spec.memory);
+    let admittedOrgScopes = [];
+    let ownOrgVerdict;
+    if (memorySpec && memorySpec.enabled && deps.memoryBackend) {
+        const outcome = await admitMemoryScopes({
+            memorySpec,
+            principal: spec.principal,
+            admission: deps.memoryScopeAdmission,
+            deploymentScopes: new Set(deps.deploymentMemoryScopes ?? []),
+            orgMemoryDenied: admissionCtx.orgMemoryDenied,
+            complianceDegraded: admissionCtx.complianceDegraded,
+            parentAdmittedOrgScopes: admissionCtx.parentAdmittedOrgScopes,
+            priorOwnVerdict: admissionCtx.priorOwnVerdict,
+            governedProvenance: admissionCtx.governedProvenance,
+        });
+        admittedOrgScopes = outcome.admittedOrgScopes;
+        ownOrgVerdict = outcome.ownVerdict;
+        for (const droppedScope of outcome.droppedDeploymentScopes) {
+            deps.onError?.(new Error(`org memory scope "${droppedScope}" (deployment-declared) was narrowed away (admission resolver or the session's frozen verdict) — the layer is not mounted this session.`), { phase: "memory", sessionId });
+        }
+        if (outcome.writeScopeNarrowed) {
+            deps.onError?.(new Error(`org memory writeScope "${String(memorySpec.writeScope)}" was not explicitly granted by admission — the session's memory write face is read-only (org layers default read-only).`), { phase: "memory", sessionId });
+        }
+        memorySpec.scopes = outcome.scopes;
+        memorySpec.writeScope = outcome.writeScope;
+    }
     const useMemoryEngine = Boolean(memorySpec && memorySpec.enabled && deps.memoryBackend);
     let memoryEngineSession;
     if (useMemoryEngine && memorySpec) {
@@ -193,5 +219,5 @@ export async function prepareMemory(input) {
         if (memoryBlock !== undefined && injection.indexSeed !== undefined)
             seedFiles = [injection.indexSeed];
     }
-    return { memoryEngineSession, memoryBlock, ...(seedFiles !== undefined ? { seedFiles } : {}) };
+    return { memoryEngineSession, memoryBlock, admittedOrgScopes, ownOrgVerdict, ...(seedFiles !== undefined ? { seedFiles } : {}) };
 }

package/dist/core/runner/prepare-task.d.ts

@@ -20,7 +20,8 @@ import type { TaskNotificationPayload } from "../task-notification.js";
 import { type CwdRef } from "../../tools/fs/index.js";
 import { type WorkflowSizeGuideline } from "../../orchestration/workflow-size-guideline.js";
 import type { Runner } from "./runtask.js";
-import { type CheckpointGate, type CheckpointState, type CheckpointStore, type CheckpointToken, type ResourceLedger, type PlatformLimitReason, type ResourceLimitReason } from "../checkpoint-store.js";
+import { type CheckpointGate, type CheckpointState, type CheckpointToken, type ResourceLedger, type PlatformLimitReason, type ResourceLimitReason } from "../checkpoint-store.js";
+import { type WiringManifest } from "../wiring-manifest.js";
 import type { ActiveWorktreeSession, AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
 import type { NestedUsageAccum, RunnerDeps, TaskEvent, TaskLimits, TaskResult, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
 import type { RepairBundle } from "../../agents/repair-loop.js";
@@ -44,11 +45,7 @@ export declare function checkpointScopeOf(spec: {
     };
     principal?: string;
 }): string;
-export declare function resolveCheckpointStore(spec: {
-    checkpointStore?: CheckpointStore | null;
-}, deps: {
-    checkpointStore?: CheckpointStore;
-}): CheckpointStore | undefined;
+export { resolveCheckpointStore } from "../checkpoint-store.js";
 export interface Prepared {
     harness: AgentHarness;
     session: StoredSession;
@@ -81,11 +78,16 @@ export interface Prepared {
     denyNarrowingPolicy?: ToolPolicy;
     basePolicyForResumeEdit?: ToolPolicy;
     releaseSignal: () => void;
+    settleContentAskBindings: () => ReadonlyArray<{
+        deliveryId: string;
+        toolCallId: string;
+    }>;
     cacheBreakDetector?: CacheBreakDetector;
     cacheFingerprint?: {
         systemPrompt: string;
         tools: ToolFingerprintInput[];
     };
+    wiringManifest: WiringManifest;
     promptManifest: {
         constitution: "core" | "replaced" | "provider-assembled";
         blocks: Array<{
@@ -294,6 +296,8 @@ export interface PrepareResume {
         }>;
     };
     workspaceHandle?: import("../remote-env.js").WorkspaceHandle;
+    redeemedContentAskCallId?: string;
+    redeemedContentAskQuestionsHash?: string;
     executesApprovedAction?: boolean;
 }
 export interface InheritedGate {
@@ -304,6 +308,8 @@ export interface InheritedGate {
         rules: SessionPermissionRules;
     }>;
     shellGate?: "off" | "always" | "classify";
+    admittedOrgScopes?: readonly string[];
+    orgAdmissionGoverned?: true;
     parentConstraints?: ReadonlyArray<{
         policy: ToolPolicy;
         onAsk?: OnAsk;
@@ -323,8 +329,13 @@ export declare function resolveModelPromptTraits(model: {
 };
 export interface RunInternals {
     repairBundle?: RepairBundle;
+    questionFaceStripped?: true;
+    parentInteractionPosture?: "interactive" | "headless";
     afterCheckpointResolve?: () => Promise<void>;
     inheritedGate?: InheritedGate;
+    ownOrgAdmissionRef?: {
+        current: import("../memory-admission.js").OwnOrgAdmissionVerdict | undefined;
+    };
     workflowDepth?: number;
     insideFork?: boolean;
     isDelegatedChild?: boolean;
@@ -336,6 +347,7 @@ export interface RunInternals {
     explicitAgentName?: string;
     parentTaskId?: string;
     parentSessionId?: string;
+    delegationTaskType?: import("../types.js").DelegationTaskType;
     rootSessionId?: string;
     registryScope?: string;
     parentCenterArtifactDigest?: string;