@sema-agent/core 1.452.0 → 2.0.0

package/dist/core/oracle-isolation.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../internal/harness.js";
+import type { ExecutionEnv } from "../internal/harness-types.js";
 export interface OracleIsolationVerdict {
     protected: boolean;
     isolationClass: "out_of_process" | "in_process_probe_only";

package/dist/core/remote-env.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../internal/harness.js";
+import type { ExecutionEnv } from "../internal/harness-types.js";
 export type SnapshotId = string;
 export type SessionToken = string;
 export type SandboxTier = 1 | 2;

package/dist/core/roles.d.ts

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "../internal/harness.js";
+import type { ThinkingLevel } from "../internal/harness-types.js";
 import type { Model } from "../internal/llm.js";
 import type { ModelRef, ModelRole, ModelRoles } from "./types.js";
 export type { ModelRole, RoleSpec, ModelRoles } from "./types.js";

package/dist/core/runner/active-skill-scope.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../../internal/harness.js";
+import type { ExecutionEnv } from "../../internal/harness-types.js";
 import type { SkillManifest, ToolEffect } from "../types.js";
 import type { ToolPolicy } from "../tool-policy.js";
 export type ActiveSkillFrame = {

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

@@ -11,13 +11,11 @@ export interface Stats {
     outputTokens: number;
     cacheHitRate?: number;
     totalInputTokens?: number;
-    costUsd: number;
     costMicroUsd: number;
     nested?: {
         tokens: number;
         turns: number;
         tasks: number;
-        costUsd?: number;
         costMicroUsd?: number;
     };
     memory?: {

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

@@ -1,5 +1,5 @@
 import type { Model } from "../../internal/llm.js";
-import type { ThinkingLevel } from "../../internal/harness.js";
+import type { ThinkingLevel } from "../../internal/harness-types.js";
 import type { Brain } from "../types.js";
 import type { MemoryStore } from "../memory.js";
 import type { ModelPricing } from "../pricing.js";

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

@@ -0,0 +1,16 @@
+import type { BeforeWriteHook, RunnerDeps, TaskSpec } from "../types.js";
+import type { Prepared } from "./prepare-task.js";
+export interface PrepareMemoryInput {
+    spec: TaskSpec;
+    deps: RunnerDeps;
+    sessionId: string;
+    taskRootPath: string;
+    memoryWriteGateRef: {
+        current?: BeforeWriteHook;
+    };
+}
+export interface PrepareMemoryResult {
+    memoryEngineSession: Prepared["memoryEngineSession"];
+    memoryBlock: string | undefined;
+}
+export declare function prepareMemory(input: PrepareMemoryInput): Promise<PrepareMemoryResult>;

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

@@ -0,0 +1,191 @@
+import { deriveControlPlaneDir, 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";
+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 memorySpec = normalizeMemorySpec(spec.memory);
+    const useMemoryEngine = Boolean(memorySpec && memorySpec.enabled && deps.memoryBackend);
+    let memoryEngineSession;
+    if (useMemoryEngine && memorySpec) {
+        try {
+            const backend = deps.memoryBackend;
+            const pinned = backend.directoryRoot;
+            const engineRoot = resolveMemoryEngineRoot(deps.memoryEngineDir);
+            const repoRoot = deps.rootPath ?? taskRootPath;
+            let identityKey;
+            if (memorySpec.scopeContract === "v2" && repoRoot) {
+                const consumesProjectIdentity = [...memorySpec.scopes, ...(memorySpec.writeScope !== null ? [memorySpec.writeScope] : [])]
+                    .map(parseScopeKey)
+                    .some((k) => k.kind === "proj" || k.kind === "userproj");
+                let marker = null;
+                try {
+                    marker = resolveProjectId(repoRoot);
+                }
+                catch (err) {
+                    if (consumesProjectIdentity)
+                        throw err;
+                    deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+                }
+                if (marker) {
+                    identityKey = marker.projectId;
+                    const firstSwitch = lookupProjectIdHint(engineRoot, repoRoot) !== marker.projectId;
+                    recordProjectIdHint(engineRoot, repoRoot, marker.projectId);
+                    if (firstSwitch) {
+                        try {
+                            const oldCtl = deriveControlPlaneDir(engineRoot, repoRoot);
+                            const newCtl = deriveProjectControlDir(engineRoot, marker.projectId);
+                            const drained = drainMemoryAnnouncements(oldCtl);
+                            for (const ann of drained.queue)
+                                enqueueMemoryAnnouncement(newCtl, ann);
+                        }
+                        catch {
+                        }
+                    }
+                    if (memorySpec.writeScope !== null) {
+                        const w = parseScopeKey(memorySpec.writeScope);
+                        if ((w.kind === "proj" || w.kind === "userproj") && w.projectId !== marker.projectId) {
+                            const e = new Error(`memory scope contract v2: writeScope ${memorySpec.writeScope} targets projectId ${w.projectId}, ` +
+                                `but this checkout's marker (.sema/project) declares ${marker.projectId} — refusing a mis-addressed write.`);
+                            e.code = "config.memory_project_identity";
+                            throw e;
+                        }
+                    }
+                }
+                else {
+                    const hint = lookupProjectIdHint(engineRoot, repoRoot);
+                    if (hint !== undefined) {
+                        deps.onError?.(new Error(`memory project marker missing but recoverable: ${repoRoot} previously carried projectId ${hint} ` +
+                            `(.sema/project deleted?). Restore the marker to keep the identity-keyed memory mount; this session ` +
+                            `falls back to the path-derived key.`), { phase: "config", sessionId });
+                    }
+                }
+            }
+            const memoryDir = typeof pinned === "string" && pinned
+                ? pinned
+                : identityKey !== undefined
+                    ? deriveProjectMemoryDir(engineRoot, identityKey)
+                    : deriveRepoMemoryDir(engineRoot, repoRoot);
+            const planes = memorySpec.scopeContract === "v2" ? classifyScopePlanes(memorySpec.scopes, memorySpec.writeScope) : undefined;
+            const dual = planes !== undefined && needsDualRoots(planes);
+            const personalOnly = planes !== undefined && !dual && planes.project.length === 0 && planes.writePlane !== "project" && (planes.personal.length > 0 || planes.writePlane === "personal");
+            if (memorySpec.scopeContract === "v2" && !personalOnly) {
+                assertScopeContractPlacement({
+                    parsedScopes: dual
+                        ? parsedProjectPlane(planes, memorySpec.writeScope)
+                        : [...memorySpec.scopes, ...(memorySpec.writeScope !== null ? [memorySpec.writeScope] : [])].map(parseScopeKey),
+                    memoryDir,
+                    repoRoot,
+                });
+            }
+            const personalMemoryDir = derivePersonalMemoryDir(engineRoot);
+            const personalControlDir = derivePersonalControlDir(engineRoot);
+            const createPersonalEngine = () => new MemoryEngine({
+                backend: typeof pinned === "string" && pinned
+                    ? new FileMemoryEngineBackend(personalMemoryDir, { controlDir: personalControlDir })
+                    : backend,
+                memoryDir: personalMemoryDir,
+                controlDir: personalControlDir,
+            });
+            let writeEngine;
+            let writeHandle;
+            let injectFn;
+            let harvestBoth;
+            if (dual) {
+                const projectEngine = new MemoryEngine({
+                    backend,
+                    memoryDir,
+                    controlDir: identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveControlPlaneDir(engineRoot, repoRoot),
+                });
+                const personalEngine = createPersonalEngine();
+                const p = planes;
+                const projectHandle = await projectEngine.materialize(p.project, p.writePlane === "project" ? memorySpec.writeScope : null);
+                const personalHandle = await personalEngine.materialize(p.personal, p.writePlane === "personal" ? memorySpec.writeScope : null);
+                const writeIsPersonal = p.writePlane === "personal";
+                writeEngine = writeIsPersonal ? personalEngine : projectEngine;
+                writeHandle = writeIsPersonal ? personalHandle : projectHandle;
+                injectFn = () => mergeInjections(projectEngine.inject(projectHandle), personalEngine.inject(personalHandle));
+                harvestBoth = async () => {
+                    const writeFirst = writeIsPersonal ? [personalEngine, personalHandle] : [projectEngine, projectHandle];
+                    const readOther = writeIsPersonal ? [projectEngine, projectHandle] : [personalEngine, personalHandle];
+                    const writeReport = await writeFirst[0].harvest(writeFirst[1]);
+                    let readReport;
+                    let readFailure;
+                    try {
+                        readReport = await readOther[0].harvest(readOther[1]);
+                    }
+                    catch (err) {
+                        readFailure = err instanceof Error ? err.message : String(err);
+                    }
+                    const merged = readReport !== undefined ? mergeHarvestReports(writeReport, readReport) : writeReport;
+                    if (readFailure !== undefined)
+                        merged.warnings.push(`read-plane harvest failed (write-plane yield committed): ${readFailure}`);
+                    return merged;
+                };
+            }
+            else if (personalOnly) {
+                const personalEngine = createPersonalEngine();
+                const handle = await personalEngine.materialize(memorySpec.scopes, memorySpec.writeScope);
+                writeEngine = personalEngine;
+                writeHandle = handle;
+                injectFn = () => personalEngine.inject(handle);
+                harvestBoth = () => personalEngine.harvest(handle);
+            }
+            else {
+                const engine = new MemoryEngine({
+                    backend,
+                    memoryDir,
+                    controlDir: identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveControlPlaneDir(engineRoot, repoRoot),
+                });
+                const handle = await engine.materialize(memorySpec.scopes, memorySpec.writeScope);
+                writeEngine = engine;
+                writeHandle = handle;
+                injectFn = () => engine.inject(handle);
+                harvestBoth = () => engine.harvest(handle);
+            }
+            memoryWriteGateRef.current = (w) => writeEngine.gateWrite(writeHandle, w.key, w.content);
+            const harvestSafe = async (phase = "terminal") => {
+                try {
+                    const report = await harvestBoth();
+                    if (!report.ok && report.incident) {
+                        deps.onError?.(new Error(`memory harvest refused (${report.incident.kind}): ${report.incident.detail}`), { phase: "memory", sessionId });
+                    }
+                    try {
+                        deps.onMemoryHarvestReport?.(report, { sessionId, phase });
+                    }
+                    catch {
+                    }
+                    return report;
+                }
+                catch (err) {
+                    try {
+                        deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "memory", sessionId });
+                    }
+                    catch {
+                    }
+                    return undefined;
+                }
+            };
+            memoryEngineSession = { engine: writeEngine, handle: writeHandle, inject: injectFn, harvest: harvestSafe };
+        }
+        catch (err) {
+            if (typeof err.code === "string" && (err.code.startsWith("config.memory_scope") || err.code.startsWith("config.memory_project"))) {
+                throw err;
+            }
+            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "memory", sessionId });
+        }
+    }
+    let memoryBlock;
+    if (memorySpec && memorySpec.enabled && !useMemoryEngine) {
+        const detail = "TaskSpec.memory is enabled but RunnerDeps.memoryBackend is not configured; memory is inactive for this task (the legacy memoryStore fallback was retired in design/138 S4 and the dep was removed in design/157 B19).";
+        deps.onError?.(new Error(detail), { phase: "config", sessionId });
+    }
+    if (memoryEngineSession) {
+        const injection = memoryEngineSession.inject();
+        if (injection.block.trim())
+            memoryBlock = injection.block;
+    }
+    return { memoryEngineSession, memoryBlock };
+}

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

@@ -1,7 +1,6 @@
 import { AgentHarness, type ThinkingLevel } from "../../internal/harness.js";
 import type { Model } from "../../internal/llm.js";
 import { type MaterializedMcp } from "../mcp.js";
-import { MemoryEngine } from "../memory-engine/engine.js";
 import type { HarvestReport, MemorySessionHandle } from "../memory-engine/types.js";
 import { StoredSession } from "../session.js";
 import type { SessionStore } from "../session.js";
@@ -12,28 +11,14 @@ import { type CutKillRegistry } from "./cut-kill.js";
 import type { SessionPermissionRules } from "../session-policy-store.js";
 import { CacheBreakDetector, type ToolFingerprintInput } from "../cache-break-detector.js";
 import { type OutputRef, type BlockedRef, type SkillListingEntry } from "./synthetic-tools.js";
-import { type ConsolidationNote } from "./memory-consolidation.js";
+import type { MemoryEngine } from "../memory-engine/engine.js";
 import type { TaskNotificationPayload } from "../task-notification.js";
 import { type CwdRef } from "../../tools/fs/index.js";
 import type { Runner } from "./runtask.js";
 import { type CheckpointGate, type CheckpointState, type CheckpointToken, type ResourceLedger, type ResourceLimitReason } from "../checkpoint-store.js";
 import type { AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
-import type { ModelRole, RunnerDeps, TaskEvent, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
+import type { RunnerDeps, TaskEvent, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
 import type { RepairBundle } from "../../agents/repair-loop.js";
-export interface PreparedConsolidation {
-    scope: string;
-    notes: ConsolidationNote[];
-    settings: {
-        role: ModelRole;
-        band: {
-            lo: number;
-            hi: number;
-        };
-        searchLimit: number;
-        maxNotes: number;
-        timeoutSec: number;
-    };
-}
 export declare const DEFAULT_IRREVERSIBLE_SCOPE = "irreversible";
 export declare function checkpointScopeOf(spec: {
     durableApproval?: {
@@ -61,7 +46,6 @@ export interface Prepared {
         tokens: number;
         turns: number;
         tasks: number;
-        costUsd: number;
         costMicroUsd: number;
     };
     cwdRef?: CwdRef;
@@ -88,7 +72,7 @@ export interface Prepared {
         tools: ToolFingerprintInput[];
     };
     promptManifest: {
-        constitution: "core" | "replaced" | "provider-assembled" | "legacy";
+        constitution: "core" | "replaced" | "provider-assembled";
         blocks: Array<{
             id: string;
             chars: number;
@@ -130,7 +114,6 @@ export interface Prepared {
         apply: (committedArtifactDigest?: string) => void;
     } | undefined;
     activeTools: Set<string>;
-    consolidation?: PreparedConsolidation;
     memoryEngineSession?: {
         engine: MemoryEngine;
         handle: MemorySessionHandle;
@@ -255,13 +238,6 @@ export interface Prepared {
     trimPressureRef: {
         droppedMessages: boolean;
     };
-    dynamicRecall?: {
-        selector: import("../memory-recall.js").MemorySelector;
-        scopes: string[];
-        recentTools: string[];
-        surfacedIds: Set<string>;
-        surfacedKeys: Set<string>;
-    };
 }
 export interface PrepareResume {
     leafId: string;
@@ -350,4 +326,4 @@ export declare function batchContextAt(messages: AgentMessage[], currentId: stri
     completedCallIds: string[];
 };
 export declare function rebaseWorkspacePath(p: string, fromRaw: string, toRaw: string): string;
-export declare function prepareTask(spec: TaskSpec, deps: RunnerDeps, sessions: SessionStore, resume?: PrepareResume, _memorySelector?: import("../memory-recall.js").MemorySelector, internals?: RunInternals, runnerSelf?: Runner): Promise<Prepared>;
+export declare function prepareTask(spec: TaskSpec, deps: RunnerDeps, sessions: SessionStore, resume?: PrepareResume, internals?: RunInternals, runnerSelf?: Runner): Promise<Prepared>;