engineering-behavior-observatory 0.2.5 → 0.2.6

package/dist/src/agent-sdk-normalizer.js

@@ -116,8 +116,8 @@ export async function readQualifiedRunCapture(bundleRoot) {
     const manifest = readManifest(root);
     await assertPersistedStructuralQualification(root, manifest);
     const qualification = await qualifyRunBundle(root);
-    if (!qualification.semanticAnalysisUsable
-        || !["qualified", "qualified-with-gaps"].includes(qualification.status)) {
+    if (!qualification.semanticAnalysisUsable || Object.entries(qualification.dimensions)
+        .some(([dimension, result]) => dimension !== "workspace" && result.status === "unqualified")) {
         const reasons = qualification.reasons.map(({ code }) => code).join(", ") || "unknown qualification failure";
         throw new Error(`Agent SDK normalization requires capture-qualified evidence: ${reasons}.`);
     }
@@ -677,11 +677,14 @@ function assertQualifiedInput(input) {
         throw new Error("Agent SDK normalization input identity is invalid.");
     }
     const kinds = new Set(input.records.map(({ record }) => record.kind));
-    for (const required of ["session", "hook", "workspace", "manifest"]) {
+    for (const required of ["session", "hook", "manifest"]) {
         if (!kinds.has(required))
             throw new Error(`Capture-qualified Agent SDK input is missing required ${required} evidence.`);
     }
     const assessmentMode = input.records.map(assessmentModeOf).find((value) => value !== undefined);
+    if (assessmentMode !== "observational" && !kinds.has("workspace")) {
+        throw new Error("Capture-qualified verified input is missing required workspace evidence.");
+    }
     if (assessmentMode !== "observational" && !input.records.some(isVerifierRecord)) {
         throw new Error("Capture-qualified verified input is missing required verifier evidence.");
     }
@@ -720,7 +723,8 @@ async function assertPersistedStructuralQualification(root, manifest) {
         return;
     const report = asRecord(parseJson(await readVerifiedArtifact(root, descriptor.relativePath, digestFrom(descriptor.digest), MAX_EVIDENCE_BYTES)));
     const structural = asRecord(report?.structuralQualification);
-    if (structural?.status === "unqualified" || structural?.semanticAnalysisUsable === false) {
+    if (structural?.semanticAnalysisUsable === false
+        || structural?.status === "unqualified" && structural?.semanticAnalysisUsable !== true) {
         throw new Error("Agent SDK normalization rejects the persisted unqualified structural capture report.");
     }
 }

package/dist/src/agent-sdk-run.js

@@ -102,8 +102,15 @@ export async function captureClaudeAgentSdkRun(options) {
             return workspace;
         },
         cleanup: async (context) => {
-            if (workspace?.status === "ready")
-                await captureWorkspace();
+            // Retain the source on packaging failure; the assembler records the outcome gap.
+            if (workspace?.status === "ready") {
+                try {
+                    await captureWorkspace();
+                }
+                catch {
+                    return;
+                }
+            }
             await options.workspace.cleanup?.(context);
         },
     };

package/dist/src/codex-run.js

@@ -89,8 +89,15 @@ export async function captureCodexAppServerRun(options) {
             return workspace;
         },
         cleanup: async (context) => {
-            if (workspace?.status === "ready")
-                await captureWorkspace();
+            // Packaging gaps must not rewrite native completion or delete recoverable work.
+            if (workspace?.status === "ready") {
+                try {
+                    await captureWorkspace();
+                }
+                catch {
+                    return;
+                }
+            }
             await options.workspace.cleanup?.(context);
         },
     };

package/dist/src/cursor-sdk.js

@@ -119,8 +119,15 @@ export async function captureCursorSdkRun(options) {
             return workspace;
         },
         cleanup: async (context) => {
-            if (workspace?.status === "ready")
-                await captureWorkspace();
+            // Retain the source on packaging failure; the assembler records the outcome gap.
+            if (workspace?.status === "ready") {
+                try {
+                    await captureWorkspace();
+                }
+                catch {
+                    return;
+                }
+            }
             await options.workspace.cleanup?.(context);
         },
     };

package/dist/src/openhands-run.js

@@ -130,7 +130,7 @@ export async function captureOpenHandsAgentServerRun(options) {
             catch (error) {
                 if (workspaceOutcome === undefined) {
                     workspaceCaptureError = error instanceof Error ? error.message : String(error);
-                    throw error;
+                    return; // Preserve native completion and the source for later capture recovery.
                 }
             }
             await options.workspace.cleanup?.(context);
@@ -318,7 +318,8 @@ export async function captureOpenHandsAgentServerRun(options) {
     const retainedWorkspacePath = workspace?.status === "ready" && workspaceOutcome === undefined
         ? workspace.path
         : undefined;
-    if (!["qualified", "qualified-with-gaps"].includes(qualification.status)) {
+    if (!qualification.semanticAnalysisUsable || Object.entries(qualification.dimensions)
+        .some(([dimension, result]) => dimension !== "workspace" && result.status === "unqualified")) {
         return {
             attempt,
             manifest,
@@ -332,7 +333,8 @@ export async function captureOpenHandsAgentServerRun(options) {
         await validateUniformEvents(normalized.events, {
             resolve: (reference) => resolvesCaptureReference(capture, reference),
         });
-        return { attempt, manifest, qualification, capture, normalized };
+        return { attempt, manifest, qualification, capture, normalized,
+            ...(retainedWorkspacePath === undefined ? {} : { retainedWorkspacePath }) };
     }
     catch (error) {
         return {

package/dist/src/pi.js

@@ -150,8 +150,15 @@ export async function capturePiSdkRun(options) {
             return workspace;
         },
         cleanup: async (context) => {
-            if (workspace?.status === "ready")
-                await captureWorkspace();
+            // Retain the source on packaging failure; the assembler records the outcome gap.
+            if (workspace?.status === "ready") {
+                try {
+                    await captureWorkspace();
+                }
+                catch {
+                    return;
+                }
+            }
             await options.workspace.cleanup?.(context);
         },
     };

package/dist/src/run-bundles.js

@@ -1,9 +1,9 @@
 import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createReadStream, createWriteStream } from "node:fs";
-import { cp, lstat, mkdir, mkdtemp, readdir, realpath, rm, rmdir, utimes, writeFile } from "node:fs/promises";
+import { cp, lstat, mkdir, mkdtemp, readdir, readlink, realpath, rm, rmdir, symlink, utimes, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, resolve, sep } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -259,7 +259,33 @@ async function withWorkspaceOutcomeProjection(options, use) {
             throw new Error(`Workspace outcome exclusion "${name}" is invalid.`);
         }
     }
-    if (exclusions.length === 0 && options.respectGitignore !== true && options.omitEmptyDirectories !== true) {
+    const absoluteLinks = [];
+    const sourceRoot = await realpath(finalPath);
+    const contained = (path) => {
+        const rel = relative(sourceRoot, path);
+        return !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+    };
+    const collectLinks = async (directory) => {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (!exclusions.includes(entry.name))
+                    await collectLinks(path);
+            }
+            else if (entry.isSymbolicLink()) {
+                const target = await readlink(path);
+                if (!isAbsolute(target))
+                    continue;
+                const resolvedTarget = await realpath(path);
+                if (!contained(resolvedTarget)) {
+                    throw new Error(`Workspace symbolic link escapes its root at "${relative(sourceRoot, path)}".`);
+                }
+                absoluteLinks.push({ path: relative(sourceRoot, path), target: relative(dirname(path), resolvedTarget) || "." });
+            }
+        }
+    };
+    await collectLinks(sourceRoot);
+    if (absoluteLinks.length === 0 && exclusions.length === 0 && options.respectGitignore !== true && options.omitEmptyDirectories !== true) {
         return use(startPath, finalPath);
     }
     await assertNoWorkspaceHardLinks(finalPath, new Set(exclusions));
@@ -274,6 +300,12 @@ async function withWorkspaceOutcomeProjection(options, use) {
             filter: async (source) => source === finalPath
                 || !await isExcludedWorkspaceDirectory(finalPath, source, exclusions),
         });
+        // Only the derived capture is relocated; native workspace link text is untouched.
+        for (const link of absoluteLinks) {
+            const path = join(projectedPath, link.path);
+            await rm(path);
+            await symlink(link.target, path);
+        }
         if (options.respectGitignore === true)
             await removeIgnoredWorkspaceEntries(startPath, projectedPath);
         if (options.omitEmptyDirectories === true)

package/dist/src/verifiers.js

@@ -91,7 +91,7 @@ async function hashWorkspaceDirectory(directory, relativeDirectory, hash, includ
                 const rel = relative(root, candidate);
                 return !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
             };
-            if (isAbsolute(target) || !contained(resolve(dirname(path), target))) {
+            if (!isAbsolute(target) && !contained(resolve(dirname(path), target))) {
                 throw new Error(`Workspace symbolic link escapes its root at "${relativePath}".`);
             }
             let resolved;

package/docs/guides/evidence-and-sharing.md

@@ -41,6 +41,20 @@ events can still explain a stop. Keep terminal state, infrastructure failure,
 and capture quality separate. Preserve `retainedWorkspacePath` when outcome
 packaging failed; that path is a recovery location, not qualified evidence.
 
+A workspace packaging error does not change a completed observational execution
+into a model or infrastructure failure. EBO omits the unpublishable workspace
+artifact, retains the source for recovery, and records the outcome gap. Native
+events, hooks, and telemetry remain available. Normalization and behavior analysis
+can use qualified semantic evidence even when the workspace dimension is
+unqualified; claims about missing work-product evidence must abstain. Verified
+tasks still require their verifier and workspace binding.
+
+Overall bundle qualification can remain `unqualified` because an outcome is
+missing. Consumers should inspect `semanticAnalysisUsable` and the individual
+qualification dimensions instead of treating that aggregate as a pipeline-wide
+fatal error. Export independently enforces its sanitization and sharing policy;
+successful capture is not permission to share.
+
 Capture reports retain packaging exceptions as `workspace-capture-error`
 missing-evidence entries. Inspect the detail before retrying capture against a
 retained workspace. A later successful capture is recovery evidence; it does
@@ -57,10 +71,13 @@ unless a fingerprint was recorded then. Do not count the recovery as another
 model trial or as an independent sample.
 
 Workspace outcomes preserve relative symbolic links whose lexical targets and
-resolved referents stay inside the workspace. Link text is hashed and copied
-verbatim, not replaced by the referent's bytes. Empty-directory omission keeps
-directories referenced by links. Absolute, escaping, dangling and
-cyclic links fail capture. Patch application or snapshot extraction must still
+resolved referents stay inside the workspace. Contained absolute links are valid:
+the derived capture rewrites them as relative links to their resolved in-workspace
+targets, so the result survives relocation. The source workspace is not changed.
+Relative link text is preserved, not replaced by the referent's bytes.
+Empty-directory omission keeps directories referenced by links. External,
+dangling and cyclic links prevent workspace artifact packaging, not native event
+capture. Patch application or snapshot extraction must still
 reproduce the resulting tree digest. This does not relax task-archive admission
 or verifier sandbox rules.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-behavior-observatory",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Capture engineering-agent trajectories, evaluate behavior, and inspect cited evidence across harnesses.",
   "license": "Apache-2.0",
   "repository": {
@@ -49,6 +49,7 @@
     "release/0.2.3/",
     "release/0.2.4/",
     "release/0.2.5/",
+    "release/0.2.6/",
     "schemas/",
     "scripts/atlas-grafana.sh"
   ],

package/release/0.2.6/KNOWN_LIMITATIONS.md

@@ -0,0 +1,15 @@
+# v0.2.6 known limitations
+
+The [v0.2.5 limitations](../0.2.5/KNOWN_LIMITATIONS.md) continue to apply, except
+that contained absolute workspace links are now supported.
+
+- Link relocation describes a derived workspace artifact, not byte-identical
+  original link text. Source directories are not modified.
+- Missing workspace evidence remains unqualified for work-product claims.
+  Semantic analysis may proceed only when its own evidence qualifies.
+- A verified task whose verifier or workspace binding fails is not reported as
+  successful. Genuine harness, setup, persistence, and cleanup errors remain
+  distinct from workspace packaging gaps.
+- Native telemetry receipt limits and provider evidence gaps are unchanged.
+- No models are rerun to recover capture. A later recovered workspace cannot
+  prove its exact earlier state without a fingerprint recorded at that time.

package/release/0.2.6/README.md

@@ -0,0 +1,26 @@
+# v0.2.6: Contain workspace capture failures
+
+Workspace outcome capture accepts absolute symbolic links that resolve inside
+the source workspace. The derived patch or snapshot uses portable relative
+links; the source workspace is unchanged. External, dangling, and cyclic links
+remain rejected for workspace packaging.
+
+A workspace packaging failure no longer rewrites native completion as an
+infrastructure failure. Capture records the missing outcome and retains the
+source for recovery. Native semantic evidence can be normalized and analyzed
+independently of workspace qualification. Verified task outcomes still require
+a verifier bound to the captured workspace. Export safety checks are unchanged.
+
+The run-manifest v1 schema now permits completed observational runs without a
+workspace artifact. Consumers must use qualification dimensions when deciding
+which evidence supports their analysis, rather than infer completeness from
+terminal state.
+
+Regression coverage includes absolute-link patch/snapshot relocation, preserved
+source links, invalid-target rejection, cleanup containment, and normalization
+with missing workspace evidence. A real retained xhigh trajectory generated 21
+structural observations without its workspace artifact and without model calls.
+
+See [known limitations](KNOWN_LIMITATIONS.md), the
+[reproducibility manifest](reproducibility.json), and the
+[evidence guide](../../docs/guides/evidence-and-sharing.md).

package/release/0.2.6/reproducibility.json

@@ -0,0 +1,74 @@
+{
+  "schemaVersion": "ebo.release-reproducibility/v1",
+  "release": {
+    "name": "engineering-behavior-observatory",
+    "version": "0.2.6"
+  },
+  "runtime": {
+    "node": "24.19.0",
+    "claudeAgentSdk": "0.3.258",
+    "openhandsAgentServer": "1.46.0",
+    "deepseekClient": "0.1.1-rc.2",
+    "deepseekProtocol": "0.1.1-rc.2",
+    "deepseekRuntime": "0.1.1-rc.2",
+    "codexAppServer": "0.153.4",
+    "grafana": "13.2.0",
+    "grafanaInfinity": "4.0.0",
+    "piSdk": "0.85.1",
+    "cursorSdk": "1.0.31"
+  },
+  "commands": [
+    "npm ci",
+    "npm run acceptance"
+  ],
+  "fixtureCoverage": {
+    "agent-sdk": "frozen queue entry through qualified capture, approved export, normalization, configurable judging, review, aggregation, and Atlas",
+    "openhands-agent-server": "pinned REST/WebSocket stream-final reconciliation, workspace/outcome evidence, partial capture, and retained evaluation",
+    "deepseek-harness": "official-client JSON-RPC composition, receipt-to-idle completion, stderr, interruption, shutdown, swaps, and retained evaluation",
+    "codex-app-server": "owned stdio lifecycle, full history, OTLP, interruption/failure, export, and retained evaluation; configurable workspace-write networking with explicit offline queue propagation",
+    "acceptance-cases": "seeded ordering, secret scanning, partial attempts, native references, abstention, disputes, denominators, and unsupported comparisons",
+    "pi-sdk": "frozen queue, passive hooks, durable session, partial cleanup, export, retained normalization and evaluation",
+    "cursor-sdk": "frozen queue, official store, callbacks/history, bounded cancellation, export, retained normalization and evaluation",
+    "workspace-capture": "Contained absolute links relocated in derived captures; workspace packaging gaps preserve native completion and allow semantic analysis independently"
+  },
+  "determinism": {
+    "stable": [
+      "task, run, attempt, event, assertion, aggregate, and Atlas case identities",
+      "fixture, native-reference, normalized-dataset, source/cohort, archive, and package digests",
+      "seeded queue and review-sample ordering"
+    ],
+    "excluded": [
+      "native and EBO observation timestamps",
+      "lifecycle start/finish timestamps",
+      "provider timing and usage",
+      "temporary workspace and output paths"
+    ]
+  },
+  "fixtures": {
+    "tests/fixtures/task-packet.valid.v1.json": "ac2ef1043c0cc16bf4c21d05c1dc880ca1b4b8cc2f9ea7653328e91f0b0e2681",
+    "test/fixtures/agent-sdk-normalizer/complete.input.json": "7285dee088517e5de38ceda84fc7c58d9303949c7448ab3b5e10a5a2d2ebdfe3",
+    "test/fixtures/agent-sdk-normalizer/complete.expected.jsonl": "d32fa3a013bc179f1673f7e1a89b8a721bb8ddaf63eba5bc8a3f14f1cc148ed8",
+    "contracts/openhands-agent-server-v1.44.1.json": "e7a07977688a0703b15751a8a1ab17f29be45f9fdf438017e0dbcbc49cca37b0",
+    "contracts/openhands-agent-server-v1.46.0.json": "455cdddd2c206cb2f20245c2189b92e773657ec14d651236baa532b2dbadeb28",
+    "test/fixtures/openhands/v1.44.1/streamed-events.json": "d751083ba2ef94c9865117db481cc2f4933772bbbbb6b9fcf60571563715c1ea",
+    "test/fixtures/openhands/v1.44.1/final-events.json": "551db9904e860004d604c923692b5c5d3aaee966220492214c60003d2df415b6",
+    "test/fixtures/deepseek/golden-success.json": "f3867d38169bf0e28f64aba1dd60553f21cf07f41f81b4bad48261e49fa3ca88",
+    "test/fixtures/deepseek/golden-interrupted.json": "79e1f8404df1ee3b562d0bdbc0b2ee712ffc6d5774992b92970814ea815677b7",
+    "test/fixtures/deepseek/compositions/minimal/composition.json": "72fe4368e105f1bad82b7fdf8380e92c9fa689d8985f6ab91f534f0baf3eda02",
+    "contracts/codex-app-server-0.153.4/manifest.json": "e62281ff5e5d1cc71d07763b85e997ccc9ddbad9aa82a469da4181ee4b1890a8",
+    "test/fixtures/codex/legacy-0.150.1.dataset.json": "f71906b009e546afbf3b4e79396f223181382f3b3d8795e9cfcd032398a9d6bf",
+    "test/fixtures/behavior-assertions/abstained.json": "7f1962864f664c794925a67d93074e7b150af0f57c58041a81e062990d641197",
+    "test/fixtures/behavior-assertions/disputed.review.json": "450d3d9efe7feefaf7500b3ad20ab2803b412c7e53b91763125e15a83be87981",
+    "test/fixtures/comparison/exact.json": "cafa68e94b8d50dc308ddcfc2e73aa139c828b4ecd1e1c762bbc51bf1b44501e",
+    "test/fixtures/structural-observations/golden.json": "bad71a3a93524b76c0a2fdbb58e98e1e65be46cae14acf18ac89d9ba76e03e8a",
+    "test/atlas-fixture.ts": "9f03ce9cbcd0e5d3e3a5916866554ceb1c21f1c8712e58529499c1ea499f048d",
+    "test/pi.test.ts": "a00997c5617ca178e19b25b0d483cbdce8ce7c306d4c871557945b31a2e657cf",
+    "test/cursor-sdk.test.ts": "753094f127b11dc392ec2244c9edddabec27aa94347bb6159a292129ed2a2822",
+    "examples/cursor-sdk/README.md": "a2cf481123e7f3deb1c5a682ba208a775c3f91c35e1a6c1a428c517c79692618",
+    "examples/cursor-sdk/capture-profile.json": "d1a5787875daf5523b3783f259b891c256a904cbb10279d5be214af846305a2d",
+    "examples/cursor-sdk/harness.json": "2f1da6f2b17258d0ee59431f687696901ce3692589175d182f3a4bbe8dd4d689",
+    "examples/cursor-sdk/model.json": "ad8f31ff5d2387c02d79226679022358afafc61ba5dda73040e3f754530a230a",
+    "examples/cursor-sdk/native-limits.json": "40fe451f56b0863e79b42f5c85defbce678e1dc90dd248d15c430db176d71511",
+    "examples/cursor-sdk/native-tool-policy.json": "0fef98b36cd39de82914c5b068022c1335dadda24b7d6e7df398b2430e6a16e0"
+  }
+}

package/release/README.md

@@ -5,6 +5,7 @@ For downloads and published artifacts, see
 
 | Version | Changes and verification | Support boundary |
 | :--- | :--- | :--- |
+| [0.2.6](0.2.6/README.md) | Portable contained absolute links; isolate workspace packaging failures from native completion and semantic analysis | [Known limitations](0.2.6/KNOWN_LIMITATIONS.md) |
 | [0.2.5](0.2.5/README.md) | Preserve contained workspace symlinks and macOS AppleDouble files | [Known limitations](0.2.5/KNOWN_LIMITATIONS.md) |
 | [0.2.4](0.2.4/README.md) | Stream workspace snapshots and integrity checks; support archives up to 1 GiB | [Known limitations](0.2.4/KNOWN_LIMITATIONS.md) |
 | [0.2.3](0.2.3/README.md) | Retain workspace capture errors in partial-bundle reports | [Known limitations](0.2.3/KNOWN_LIMITATIONS.md) |

package/schemas/run-bundles/v1.json

@@ -179,7 +179,6 @@
         {
           "if": { "properties": { "state": { "const": "completed" } }, "required": ["state"] },
           "then": {
-            "required": ["workspaceArtifactId"],
             "properties": {
               "failureClass": { "const": "none" },
               "stopReason": { "const": "none" }