@empire-builder-kit/nx 1.0.0-rc.41 → 1.0.0-rc.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empire-builder-kit/nx",
-  "version": "1.0.0-rc.41",
+  "version": "1.0.0-rc.43",
   "description": "Nx generators, executors, and Blueprint contracts for Empire Builder Kit",
   "keywords": [
     "aws",
@@ -145,12 +145,12 @@
     "provenance": false
   },
   "dependencies": {
-    "@empire-builder-kit/runtime": "1.0.0-rc.41",
+    "@empire-builder-kit/runtime": "1.0.0-rc.43",
     "@aws-sdk/client-cloudfront": "^3.700.0",
     "@aws-sdk/client-cloudwatch": "^3.700.0",
     "@aws-sdk/client-cloudwatch-logs": "^3.700.0",
     "@aws-sdk/client-iam": "^3.700.0",
-    "@nx/devkit": "23.1.0",
+    "@nx/devkit": "23.2.1",
     "@aws-sdk/client-rds": "^3.700.0",
     "@aws-sdk/client-s3": "^3.700.0",
     "@aws-sdk/client-secrets-manager": "^3.700.0",
@@ -159,7 +159,7 @@
     "@aws-sdk/client-wafv2": "^3.700.0",
     "@aws-sdk/credential-providers": "^3.700.0",
     "ajv": "8.20.0",
-    "nx": "23.1.0",
+    "nx": "23.2.1",
     "prettier": "^3.8.2",
     "semver": "7.7.4",
     "tslib": "^2.3.0",
@@ -178,5 +178,5 @@
   "engines": {
     "node": ">=22.13.0"
   },
-  "gitHead": "6c8e932ac3acf0a1e124f7687cd7b8582b864c49"
+  "gitHead": "7703b131fbcd59bc364ce7f914a1ff22250378c9"
 }

package/src/cli/agent-runtime.js

@@ -259,7 +259,11 @@ async function executeDeveloperAgentCommand(command, workspaceRoot, overrides =
         ...overrides,
     };
     if (command.command === 'context') {
-        const context = await dependencies.inspectContext(workspaceRoot, command.query);
+        const inspected = await dependencies.inspectContext(workspaceRoot, command.query);
+        // The context leaves the process here, so this is where the transport
+        // byte bound applies; plan, upgrade preview and resume keep the complete
+        // in-process context.
+        const { context } = (0, context_js_1.serializeDeveloperAgentContextForTransport)(inspected);
         const blockingClassification = model_js_1.DEVELOPER_AGENT_CONTEXT_BLOCKING_FAILURES.find((classification) => context.warnings.some((warning) => warning.classification === classification));
         return {
             human: (0, context_js_1.formatDeveloperAgentContext)(context),
@@ -446,6 +450,12 @@ async function executeDeveloperAgentCommand(command, workspaceRoot, overrides =
     };
 }
 function classifyDeveloperAgentCliError(error) {
+    // Must precede the generic DeveloperAgentContextError branch, which would
+    // redact this tool-internal-error message. The bound message carries only
+    // counts, byte sizes and the selection remedy.
+    if (error instanceof context_js_1.DeveloperAgentContextBoundError) {
+        return { classification: error.classification, message: error.message };
+    }
     if (error instanceof DeveloperAgentCliError ||
         error instanceof context_js_1.DeveloperAgentContextError ||
         error instanceof handoff_js_1.DeveloperAgentHandoffError ||

package/src/cli/deploy-runtime.d.ts

@@ -9,7 +9,15 @@ export interface DeployResultProject {
 }
 /** The development-only `--json` result: the executor's own written receipt
  * (already secret-free evidence) and per-project status. It is printed after
- * the run and carries no authority; protected stages never produce it. */
+ * the run and carries no authority; protected stages never produce it.
+ *
+ * `outcome` and `exitCode` are two independent facts and are never
+ * reconciled. `outcome` is the verdict of this run's fresh receipt (or
+ * `receipt-unavailable`); `exitCode` is the lifecycle process's own exit
+ * status, 128 plus the signal number when it was signalled, and is also the
+ * command's exit status. They can disagree, for example when the process is
+ * interrupted after the executor wrote a `succeeded` receipt. Success
+ * requires both `exitCode` 0 and `outcome` `succeeded`. */
 export interface DeployJsonResult {
     exitCode: number;
     kind: typeof DEPLOY_RESULT_KIND;

package/src/developer-agent/context.d.ts

@@ -22,6 +22,36 @@ export declare class DeveloperAgentContextError extends Error {
     readonly classification: DeveloperAgentFailureClassification;
     constructor(classification: DeveloperAgentFailureClassification, message: string);
 }
+/**
+ * The framework produced a context larger than its fixed transport bound even
+ * after bounding the concurrent-change list. This is not a missing local
+ * prerequisite and not caller input: the message carries only counts and
+ * byte sizes (never paths) plus the selection remedy, so the CLI may pass it
+ * through instead of the generic internal-failure text.
+ */
+export declare class DeveloperAgentContextBoundError extends DeveloperAgentContextError {
+    constructor(message: string);
+}
 export declare function resolveAffectedProjectsWithNx(workspaceRoot: string, baseCommit: string, headCommit: string): Promise<readonly string[]>;
 export declare function inspectDeveloperAgentContext(cwd: string, query?: DeveloperAgentContextQuery, dependencyOverrides?: Partial<DeveloperAgentContextDependencies>): Promise<DeveloperAgentContext>;
+/**
+ * Projects the complete in-process context into its emitted form. When the
+ * complete context fits the transport bound it is emitted unchanged apart
+ * from the summary fields. Otherwise concurrent changes inside the
+ * selection's coverage are retained first, then the rest, filling the byte
+ * budget exactly; the retained subset stays in canonical order and the
+ * count, digest and truncation flag describe the complete list. A context
+ * that cannot fit even with every concurrent change omitted raises
+ * DeveloperAgentContextBoundError.
+ */
+export declare function projectDeveloperAgentContextForTransport(context: DeveloperAgentContext): DeveloperAgentContext;
+/**
+ * The single emit-point serializer: projects, then serializes under the
+ * transport bound. Every emitted context (CLI JSON payload and executor
+ * fingerprint) goes through here.
+ */
+export declare function serializeDeveloperAgentContextForTransport(context: DeveloperAgentContext): {
+    context: DeveloperAgentContext;
+    serialized: string;
+};
 export declare function formatDeveloperAgentContext(context: DeveloperAgentContext): string;

package/src/developer-agent/context.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeveloperAgentContextError = exports.DEVELOPER_AGENT_CONTEXT_HUMAN_MAX_BYTES = void 0;
+exports.DeveloperAgentContextBoundError = exports.DeveloperAgentContextError = exports.DEVELOPER_AGENT_CONTEXT_HUMAN_MAX_BYTES = void 0;
 exports.resolveAffectedProjectsWithNx = resolveAffectedProjectsWithNx;
 exports.inspectDeveloperAgentContext = inspectDeveloperAgentContext;
+exports.projectDeveloperAgentContextForTransport = projectDeveloperAgentContextForTransport;
+exports.serializeDeveloperAgentContextForTransport = serializeDeveloperAgentContextForTransport;
 exports.formatDeveloperAgentContext = formatDeveloperAgentContext;
 const devkit_1 = require("@nx/devkit");
 const node_child_process_1 = require("node:child_process");
@@ -10,11 +12,13 @@ const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
+const canonical_json_1 = require("@empire-builder-kit/runtime/canonical-json");
 const nx_workspace_js_1 = require("../local-dev/nx-workspace.js");
 const resolver_js_1 = require("../blueprints/resolver.js");
 const blueprint_trust_git_js_1 = require("../supply-chain/blueprint-trust-git.js");
 const blueprint_verification_authority_js_1 = require("../supply-chain/blueprint-verification-authority.js");
 const git_inspection_js_1 = require("./git-inspection.js");
+const model_js_1 = require("./model.js");
 const ordering_js_1 = require("./ordering.js");
 const validation_js_1 = require("./validation.js");
 const workspace_inspection_js_1 = require("./workspace-inspection.js");
@@ -43,6 +47,20 @@ class DeveloperAgentContextError extends Error {
     }
 }
 exports.DeveloperAgentContextError = DeveloperAgentContextError;
+/**
+ * The framework produced a context larger than its fixed transport bound even
+ * after bounding the concurrent-change list. This is not a missing local
+ * prerequisite and not caller input: the message carries only counts and
+ * byte sizes (never paths) plus the selection remedy, so the CLI may pass it
+ * through instead of the generic internal-failure text.
+ */
+class DeveloperAgentContextBoundError extends DeveloperAgentContextError {
+    constructor(message) {
+        super('tool-internal-error', message);
+        this.name = 'DeveloperAgentContextBoundError';
+    }
+}
+exports.DeveloperAgentContextBoundError = DeveloperAgentContextBoundError;
 function contained(root, path) {
     const fromRoot = (0, node_path_1.relative)(root, path);
     return (fromRoot === '' ||
@@ -178,10 +196,24 @@ async function resolveAffectedProjectsWithNx(workspaceRoot, baseCommit, headComm
         return fail('prerequisite-missing', 'Workspace-pinned Nx affected inspection failed for the exact base/head pair.');
     }
 }
+function concurrentChangeSummary(concurrentChanges) {
+    return {
+        concurrentChangeCount: concurrentChanges.length,
+        concurrentChangesDigest: `sha256:${(0, node_crypto_1.createHash)('sha256')
+            .update((0, canonical_json_1.canonicalJson)(concurrentChanges), 'utf8')
+            .digest('hex')}`,
+    };
+}
 function gitContext(inspection) {
     if (!inspection.defaultBase) {
         return fail('tool-internal-error', 'Git inspection omitted the workspace default-base binding.');
     }
+    const concurrentChanges = inspection.concurrentChanges.map(({ committed, dirty, path, worktreeRoots }) => ({
+        committed,
+        dirty,
+        path,
+        worktreeCount: worktreeRoots.length,
+    }));
     return {
         ahead: inspection.worktree.upstream?.ahead ?? 0,
         ...(inspection.comparison
@@ -192,13 +224,10 @@ function gitContext(inspection) {
             ? { branch: inspection.worktree.branch }
             : {}),
         commit: inspection.worktree.commit,
+        ...concurrentChangeSummary(concurrentChanges),
         concurrentChangeInspectionComplete: inspection.concurrentChangeInspectionComplete,
-        concurrentChanges: inspection.concurrentChanges.map(({ committed, dirty, path, worktreeRoots }) => ({
-            committed,
-            dirty,
-            path,
-            worktreeCount: worktreeRoots.length,
-        })),
+        concurrentChanges,
+        concurrentChangesTruncated: false,
         defaultBaseCommit: inspection.defaultBase.commit,
         defaultBaseRef: inspection.defaultBase.ref,
         dirty: inspection.worktree.dirtyPaths.length > 0,
@@ -308,6 +337,12 @@ function boundedAffectedFiles(paths) {
 function classifyWorkspaceFailure(error) {
     if (error instanceof DeveloperAgentContextError)
         throw error;
+    if (error instanceof validation_js_1.DeveloperAgentContractValidationError) {
+        // The framework assembled a context that breaks its own contract. That is
+        // neither caller input nor a missing local prerequisite, so it must not
+        // reach the message-pattern classification below.
+        return fail('tool-internal-error', INTERNAL_CONTEXT_FAILURE_MESSAGE);
+    }
     const message = error instanceof Error ? error.message : String(error);
     if (/policy/i.test(message)) {
         return fail('policy-conflict', 'Developer-Agent workspace policy inspection reported a conflict.');
@@ -445,13 +480,111 @@ async function inspectDeveloperAgentContext(cwd, query = {}, dependencyOverrides
                 ? 'dirty-worktree'
                 : 'stale-base', 'Git state changed while Developer-Agent context was inspected.');
         }
-        (0, validation_js_1.serializeDeveloperAgentContext)(result);
-        return result;
+        // Structure only: the transport byte bound applies where the context
+        // leaves the process (serializeDeveloperAgentContextForTransport), so
+        // plan, upgrade preview and handoff resume keep every inspected fact.
+        return (0, validation_js_1.assertDeveloperAgentContextStructure)(result);
     }
     catch (error) {
         return classifyWorkspaceFailure(error);
     }
 }
+function canonicalByteLength(value) {
+    return Buffer.byteLength((0, canonical_json_1.canonicalJson)(value), 'utf8');
+}
+function withConcurrentChanges(context, concurrentChanges, complete, truncated) {
+    return {
+        ...context,
+        git: {
+            ...context.git,
+            ...concurrentChangeSummary(complete),
+            concurrentChanges,
+            concurrentChangesTruncated: truncated,
+        },
+    };
+}
+/**
+ * Paths most relevant to the selection: anything under a selected project's
+ * root, root-level files, and the workspace `.ebk/` directory. A project
+ * rooted at the workspace root contributes only those root-level paths rather
+ * than the whole tree.
+ */
+function concurrentChangeCoverage(context) {
+    const prefixes = context.projects
+        .map(({ root }) => root.replace(/\/+$/, ''))
+        .filter((root) => root !== '' && root !== '.')
+        .map((root) => `${root}/`);
+    return (path) => !path.includes('/') ||
+        path.startsWith('.ebk/') ||
+        prefixes.some((prefix) => path.startsWith(prefix));
+}
+function contextBoundError(context, projectedBytes, retainedConcurrentChanges) {
+    const complete = context.git.concurrentChanges;
+    return new DeveloperAgentContextBoundError(`Developer-Agent context exceeds its ${model_js_1.DEVELOPER_AGENT_CONTEXT_MAX_BYTES}-byte transport bound: it needs ${projectedBytes} canonical bytes with ${retainedConcurrentChanges} of ${complete.length} concurrent change(s) retained (${canonicalByteLength(complete)} bytes complete); ${context.supportedOperations.length} supported operation(s) use ${canonicalByteLength(context.supportedOperations)} bytes. Narrow the selection with --projects=<slice[,slice]>.`);
+}
+/**
+ * Projects the complete in-process context into its emitted form. When the
+ * complete context fits the transport bound it is emitted unchanged apart
+ * from the summary fields. Otherwise concurrent changes inside the
+ * selection's coverage are retained first, then the rest, filling the byte
+ * budget exactly; the retained subset stays in canonical order and the
+ * count, digest and truncation flag describe the complete list. A context
+ * that cannot fit even with every concurrent change omitted raises
+ * DeveloperAgentContextBoundError.
+ */
+function projectDeveloperAgentContextForTransport(context) {
+    const complete = context.git.concurrentChanges;
+    const untruncated = withConcurrentChanges(context, complete, complete, false);
+    if (canonicalByteLength(untruncated) <= model_js_1.DEVELOPER_AGENT_CONTEXT_MAX_BYTES) {
+        return untruncated;
+    }
+    // Measure the empty projection with the longer `false` literal so that a
+    // budget which admits every entry is impossible here: the complete list
+    // was already shown not to fit, so the emitted flag is always honest.
+    const minimumBytes = canonicalByteLength(withConcurrentChanges(context, [], complete, false));
+    if (minimumBytes > model_js_1.DEVELOPER_AGENT_CONTEXT_MAX_BYTES) {
+        throw contextBoundError(context, minimumBytes, 0);
+    }
+    const covered = concurrentChangeCoverage(context);
+    const prioritized = [
+        ...complete.filter(({ path }) => covered(path)),
+        ...complete.filter(({ path }) => !covered(path)),
+    ];
+    const retained = new Set();
+    let remaining = model_js_1.DEVELOPER_AGENT_CONTEXT_MAX_BYTES - minimumBytes;
+    for (const entry of prioritized) {
+        const cost = canonicalByteLength(entry) + (retained.size > 0 ? 1 : 0);
+        if (cost > remaining)
+            break;
+        remaining -= cost;
+        retained.add(entry);
+    }
+    return withConcurrentChanges(context, complete.filter((entry) => retained.has(entry)), complete, true);
+}
+/**
+ * The single emit-point serializer: projects, then serializes under the
+ * transport bound. Every emitted context (CLI JSON payload and executor
+ * fingerprint) goes through here.
+ */
+function serializeDeveloperAgentContextForTransport(context) {
+    const projected = projectDeveloperAgentContextForTransport(context);
+    try {
+        return {
+            context: projected,
+            serialized: (0, validation_js_1.serializeDeveloperAgentContext)(projected),
+        };
+    }
+    catch (error) {
+        if (error instanceof validation_js_1.DeveloperAgentContractValidationError) {
+            if (error.issues.length > 0 &&
+                error.issues.every(({ message, path }) => path === '$' && message.startsWith('must serialize to at most'))) {
+                throw contextBoundError(context, canonicalByteLength(projected), projected.git.concurrentChanges.length);
+            }
+            return fail('tool-internal-error', INTERNAL_CONTEXT_FAILURE_MESSAGE);
+        }
+        throw error;
+    }
+}
 function formatDeveloperAgentContext(context) {
     const branch = context.git.branch ?? '(detached)';
     const selection = context.selection.slice

package/src/developer-agent/handoff.js

@@ -207,6 +207,19 @@ function inspectRetainedEvidence(workspaceRoot, handoff) {
 function invalidInput(message) {
     throw new DeveloperAgentHandoffError('invalid-input', message);
 }
+/** Issue paths named in one invalid-handoff message; the rest are counted. */
+const MAX_REPORTED_HANDOFF_ISSUE_PATHS = 16;
+/**
+ * Names every distinct validation issue path, sorted and bounded, so one
+ * attempt surfaces all refusals. Paths carry only fixed property names and
+ * array indexes (unknown properties are reported as `.*`), never values.
+ */
+function invalidHandoff(issues) {
+    const paths = [...new Set(issues.map(({ path }) => path))].sort(ordering_js_1.compareDeveloperAgentStrings);
+    const reported = paths.slice(0, MAX_REPORTED_HANDOFF_ISSUE_PATHS);
+    const omitted = paths.length - reported.length;
+    return invalidInput(`Retained Developer-Agent handoff is invalid at ${reported.length > 0 ? reported.join(', ') : '$'}${omitted > 0 ? ` and ${omitted} more issue paths` : ''}.`);
+}
 function compareStrings(left, right) {
     if (left.length !== right.length)
         return false;
@@ -331,8 +344,7 @@ function parseDeveloperAgentHandoff(serialized) {
     }
     const validation = (0, validation_js_1.validateDeveloperAgentHandoff)(value);
     if (!validation.valid) {
-        const firstPath = validation.issues[0]?.path ?? '$';
-        return invalidInput(`Retained Developer-Agent handoff is invalid at ${firstPath}.`);
+        return invalidHandoff(validation.issues);
     }
     const handoff = validation.value;
     const sentinelPath = /^(?:0{40}|0{64})$/.test(handoff.repository.baseCommit)
@@ -368,10 +380,13 @@ function parseDeveloperAgentHandoff(serialized) {
 function assessDeveloperAgentHandoffResumeInternal(handoff, current, evidenceInspection) {
     const validation = (0, validation_js_1.validateDeveloperAgentHandoff)(handoff);
     if (!validation.valid) {
-        const firstPath = validation.issues[0]?.path ?? '$';
-        return invalidInput(`Retained Developer-Agent handoff is invalid at ${firstPath}.`);
+        return invalidHandoff(validation.issues);
     }
-    const contextValidation = (0, validation_js_1.validateDeveloperAgentContext)(current);
+    // Resume consumes the in-process context and never emits it, so only its
+    // structure is checked; the transport byte bound applies at emit points.
+    const contextValidation = (0, validation_js_1.validateDeveloperAgentContext)(current, {
+        transportBound: false,
+    });
     if (!contextValidation.valid) {
         return createAssessment(validation.value, [
             {

package/src/developer-agent/model.d.ts

@@ -161,8 +161,18 @@ export interface DeveloperAgentGitContext {
     branch?: string;
     /** Null means a verified unborn symbolic branch, never a placeholder SHA. */
     commit: string | null;
+    /** Number of entries in the complete inspected concurrent-change list. */
+    concurrentChangeCount?: number;
     concurrentChangeInspectionComplete: boolean;
+    /**
+     * The in-process context carries every inspected entry. An emitted context
+     * may carry a byte-bounded subset; count, digest and truncation then
+     * describe the complete list.
+     */
     concurrentChanges: readonly DeveloperAgentConcurrentChangeContext[];
+    /** SHA-256 of the canonical JSON of the complete concurrent-change list. */
+    concurrentChangesDigest?: string;
+    concurrentChangesTruncated?: boolean;
     /** An implicit base may be absent during local first-use orientation. */
     defaultBaseCommit: string | null;
     defaultBaseRef: string;

package/src/developer-agent/operation-registry.js

@@ -603,9 +603,11 @@ const TARGET_RULES = [
         matches: exact('github-bootstrap', 'secret-initialize'),
         requiredVerification: ['source', 'protected-proof'],
     },
-    // Report-first plans, collectors and deployed verification read and
-    // propose only; staging and production reach stays bounded by the
-    // deployment role, not by a plan-time approval point.
+    // Report-first plans and collectors read and propose only. Deployed
+    // verification (smoke-deployed) is bounded synthetic verification that
+    // creates and deletes synthetic users and data. Staging and production
+    // reach stays bounded by the deployment role, not by a plan-time approval
+    // point.
     {
         approvalRequired: false,
         authority: 'protected-propose',

package/src/developer-agent/planning.js

@@ -144,6 +144,14 @@ function concurrentPathBlockers(context, plannedPaths, readOnly) {
             sanitizedSummary: 'Committed-path inspection for another linked worktree is incomplete, so mutation planning cannot exclude an overlap.',
         });
     }
+    if (context.git.concurrentChangesTruncated === true) {
+        // Planning consumes the complete in-process context. A byte-bounded
+        // emitted projection cannot exclude an overlap, so it fails closed.
+        blockers.push({
+            classification: 'stale-base',
+            sanitizedSummary: 'The concurrent-change list is a truncated transport projection, so mutation planning cannot exclude an overlap.',
+        });
+    }
     const plannedKeys = new Set(plannedPaths.map((path) => path.normalize('NFC').toLocaleLowerCase('en-US')));
     const overlaps = (context.git.concurrentChanges ?? []).filter(({ path }) => plannedKeys.has(path.normalize('NFC').toLocaleLowerCase('en-US')));
     if (overlaps.length > 0) {

package/src/developer-agent/validation.d.ts

@@ -4,13 +4,25 @@ export declare class DeveloperAgentContractValidationError extends Error {
     readonly issues: readonly ValidationIssue[];
     constructor(label: string, issues: readonly ValidationIssue[]);
 }
-export declare function validateDeveloperAgentContext(value: unknown): ValidationResult<DeveloperAgentContext>;
+export interface DeveloperAgentContextValidationOptions {
+    /**
+     * The byte bound applies where a context leaves the process (the context
+     * CLI JSON payload and the developer-context executor). The in-process
+     * context that planning, upgrade preview and handoff resume consume keeps
+     * every inspected fact and is validated for structure only.
+     */
+    transportBound?: boolean;
+}
+export declare function validateDeveloperAgentContext(value: unknown, options?: DeveloperAgentContextValidationOptions): ValidationResult<DeveloperAgentContext>;
 export declare function validateDeveloperAgentGeneratorPreview(value: unknown): ValidationResult<DeveloperAgentGeneratorPreview>;
 export declare function validateDeveloperAgentGeneratorPreviewReceipt(value: unknown): ValidationResult<DeveloperAgentGeneratorPreviewReceipt>;
 export declare function validateDeveloperAgentPlan(value: unknown): ValidationResult<DeveloperAgentPlan>;
 export declare function validateDeveloperAgentResult(value: unknown): ValidationResult<DeveloperAgentResult>;
 export declare function validateDeveloperAgentHandoff(value: unknown): ValidationResult<DeveloperAgentHandoff>;
+/** Serializes an emitted context and enforces its transport byte bound. */
 export declare function serializeDeveloperAgentContext(value: unknown): string;
+/** Validates the in-process context for structure only and returns it. */
+export declare function assertDeveloperAgentContextStructure(value: unknown): DeveloperAgentContext;
 export declare function serializeDeveloperAgentGeneratorPreview(value: unknown): string;
 export declare function serializeDeveloperAgentGeneratorPreviewReceipt(value: unknown): string;
 export declare function serializeDeveloperAgentPlan(value: unknown): string;

package/src/developer-agent/validation.js

@@ -8,6 +8,7 @@ exports.validateDeveloperAgentPlan = validateDeveloperAgentPlan;
 exports.validateDeveloperAgentResult = validateDeveloperAgentResult;
 exports.validateDeveloperAgentHandoff = validateDeveloperAgentHandoff;
 exports.serializeDeveloperAgentContext = serializeDeveloperAgentContext;
+exports.assertDeveloperAgentContextStructure = assertDeveloperAgentContextStructure;
 exports.serializeDeveloperAgentGeneratorPreview = serializeDeveloperAgentGeneratorPreview;
 exports.serializeDeveloperAgentGeneratorPreviewReceipt = serializeDeveloperAgentGeneratorPreviewReceipt;
 exports.serializeDeveloperAgentPlan = serializeDeveloperAgentPlan;
@@ -466,6 +467,37 @@ function validateOwnershipVersionStates(value, path, issues) {
     });
     return true;
 }
+const CONCURRENT_CHANGE_SUMMARY_KEYS = [
+    'concurrentChangeCount',
+    'concurrentChangesDigest',
+    'concurrentChangesTruncated',
+];
+/**
+ * The complete concurrent-change list is summarized by an exact count, a
+ * digest and a truncation flag. The three fields appear together or not at
+ * all, and an emitted subset must state honestly that it is a subset.
+ */
+function validateConcurrentChangeSummary(record, concurrentChanges, path, issues) {
+    const present = CONCURRENT_CHANGE_SUMMARY_KEYS.filter((key) => has(record, key));
+    if (present.length === 0)
+        return;
+    if (present.length !== CONCURRENT_CHANGE_SUMMARY_KEYS.length) {
+        addIssue(issues, path, 'must carry concurrentChangeCount, concurrentChangesDigest and concurrentChangesTruncated together');
+        return;
+    }
+    const countValid = requireInteger(record.concurrentChangeCount, `${path}.concurrentChangeCount`, issues, 0, MAX_CONCURRENT_PATHS);
+    requireSafeString(record.concurrentChangesDigest, `${path}.concurrentChangesDigest`, issues, { maximumLength: 71, pattern: SHA256_DIGEST_PATTERN });
+    const truncatedValid = requireBoolean(record.concurrentChangesTruncated, `${path}.concurrentChangesTruncated`, issues);
+    if (!countValid || !truncatedValid || !concurrentChanges)
+        return;
+    const count = record.concurrentChangeCount;
+    if ((record.concurrentChangesTruncated === false &&
+        count !== concurrentChanges.length) ||
+        (record.concurrentChangesTruncated === true &&
+            count <= concurrentChanges.length)) {
+        addIssue(issues, path, 'must retain an exact concurrent-change count and an honest truncation state');
+    }
+}
 function validateGitContext(value, path, issues) {
     const record = requireRecord(value, path, [
         'ahead',
@@ -477,7 +509,15 @@ function validateGitContext(value, path, issues) {
         'defaultBaseRef',
         'dirty',
         'worktreeRoot',
-    ], ['baseCommit', 'branch', 'headCommit', 'upstream'], issues);
+    ], [
+        'baseCommit',
+        'branch',
+        'concurrentChangeCount',
+        'concurrentChangesDigest',
+        'concurrentChangesTruncated',
+        'headCommit',
+        'upstream',
+    ], issues);
     if (!record)
         return false;
     requireInteger(record.ahead, `${path}.ahead`, issues, 0, 1_000_000);
@@ -530,6 +570,7 @@ function validateGitContext(value, path, issues) {
         }
         requireInteger(concurrent.worktreeCount, `${entryPath}.worktreeCount`, issues, 1, 64);
     });
+    validateConcurrentChangeSummary(record, concurrentChanges, path, issues);
     if (record.defaultBaseCommit !== null) {
         requireSafeString(record.defaultBaseCommit, `${path}.defaultBaseCommit`, issues, {
             maximumLength: 64,
@@ -1023,9 +1064,11 @@ function validateSerializedBound(value, path, maximumBytes, issues) {
         addIssue(issues, path, 'must be canonically JSON serializable');
     }
 }
-function validateDeveloperAgentContext(value) {
+function validateDeveloperAgentContext(value, options = {}) {
     const issues = [];
-    validateSerializedBound(value, '$', model_js_1.DEVELOPER_AGENT_CONTEXT_MAX_BYTES, issues);
+    if (options.transportBound !== false) {
+        validateSerializedBound(value, '$', model_js_1.DEVELOPER_AGENT_CONTEXT_MAX_BYTES, issues);
+    }
     const record = requireRecord(value, '$', [
         'authenticatedTargets',
         'documentationPaths',
@@ -2297,8 +2340,15 @@ function validateHandoffCoherence(record, issues) {
             const affectedProjects = Array.isArray(affected?.projects)
                 ? affected.projects.filter((value) => typeof value === 'string')
                 : [];
+            // Generated native producers record the workspace's exact
+            // @empire-builder-kit/runtime pin, which the preset keeps equal to the
+            // installed @empire-builder-kit/nx version; the package-qualified form
+            // stays accepted for hand-composed evidence. Both are exact equality to
+            // the retained framework version, so evidence from another candidate is
+            // refused.
             if (testingSource &&
                 typeof versions?.frameworkVersion === 'string' &&
+                testingSource.frameworkCandidate !== versions.frameworkVersion &&
                 testingSource.frameworkCandidate !==
                     `@empire-builder-kit/nx@${versions.frameworkVersion}`) {
                 addIssue(issues, `$.results[${index}].testingEvidence.result.source.frameworkCandidate`, 'must match the retained framework candidate');
@@ -2360,15 +2410,46 @@ function validateHandoffCoherence(record, issues) {
                         testingEnvironment.stage !== versions.canonicalStage))) {
                 addIssue(issues, `$.results[${index}].testingEvidence.result.environment.stage`, 'must be present for deployed proof and exactly match the retained canonical stage');
             }
+            // Registered target operations scope requiredVerification by proof
+            // class (for example local-integration), so their own native evidence is
+            // bound by operation identity instead; proofLayer stays bound to the
+            // retained required evidence below. Source-edit results keep the
+            // project:target verification vocabulary.
+            const resultOperation = (0, validation_js_1.isRecord)(result.operation)
+                ? result.operation
+                : undefined;
+            const evidenceIsOwnOperation = typeof testingOperation?.project === 'string' &&
+                typeof testingOperation.target === 'string' &&
+                resultOperation?.name ===
+                    `target:${testingOperation.project}:${testingOperation.target}`;
             if (typeof testingOperation?.target === 'string' &&
+                !evidenceIsOwnOperation &&
                 !requiredVerification.some((value) => typeof value === 'string' &&
                     (value === testingOperation.target ||
                         value.endsWith(`:${testingOperation.target}`)))) {
                 addIssue(issues, `$.results[${index}].testingEvidence.result.operation.target`, 'must be accounted for by retained required verification');
             }
+            // An own registered target's proof class is bound to that operation's
+            // retained evidence scope, never to a class another operation
+            // contributes to the handoff-wide union. Resume separately requires the
+            // retained scope to equal the current registry scope.
+            const ownRetainedOperation = evidenceIsOwnOperation
+                ? operations.find((operation) => operation.id === resultOperation?.name)
+                : undefined;
+            const ownRetainedScope = (0, validation_js_1.isRecord)(ownRetainedOperation?.scope)
+                ? ownRetainedOperation.scope
+                : undefined;
+            const proofLayerScope = evidenceIsOwnOperation
+                ? Array.isArray(ownRetainedScope?.evidenceClasses)
+                    ? ownRetainedScope.evidenceClasses
+                    : []
+                : requiredEvidence;
             if (typeof testingOperation?.proofLayer === 'string' &&
-                !requiredEvidence.includes(testingOperation.proofLayer)) {
-                addIssue(issues, `$.results[${index}].testingEvidence.result.operation.proofLayer`, 'must be accounted for by retained required evidence');
+                (!requiredEvidence.includes(testingOperation.proofLayer) ||
+                    !proofLayerScope.includes(testingOperation.proofLayer))) {
+                addIssue(issues, `$.results[${index}].testingEvidence.result.operation.proofLayer`, evidenceIsOwnOperation
+                    ? 'must be accounted for by the retained evidence scope of its own operation'
+                    : 'must be accounted for by retained required evidence');
             }
             if (testingEvidence && testingResult) {
                 const outerArtifacts = Array.isArray(result.artifacts)
@@ -2612,8 +2693,19 @@ function serializeValidated(label, value, validate) {
     }
     return (0, canonical_json_1.canonicalJson)(result.value);
 }
+/** Serializes an emitted context and enforces its transport byte bound. */
 function serializeDeveloperAgentContext(value) {
-    return serializeValidated('Developer-Agent context', value, validateDeveloperAgentContext);
+    return serializeValidated('Developer-Agent context', value, (candidate) => validateDeveloperAgentContext(candidate));
+}
+/** Validates the in-process context for structure only and returns it. */
+function assertDeveloperAgentContextStructure(value) {
+    const result = validateDeveloperAgentContext(value, {
+        transportBound: false,
+    });
+    if (!result.valid) {
+        throw new DeveloperAgentContractValidationError('Developer-Agent context', result.issues);
+    }
+    return result.value;
 }
 function serializeDeveloperAgentGeneratorPreview(value) {
     return serializeValidated('Developer-Agent generator preview', value, validateDeveloperAgentGeneratorPreview);

package/src/executors/developer-context/developer-context.js

@@ -10,7 +10,6 @@ const node_buffer_1 = require("node:buffer");
 const node_crypto_1 = require("node:crypto");
 const context_js_1 = require("../../developer-agent/context.js");
 const model_js_1 = require("../../developer-agent/model.js");
-const validation_js_1 = require("../../developer-agent/validation.js");
 exports.DEVELOPER_AGENT_CONTEXT_FINGERPRINT_KIND = 'developer-agent-context-fingerprint';
 exports.DEVELOPER_AGENT_CONTEXT_FINGERPRINT_SCHEMA_VERSION = 1;
 exports.DEVELOPER_AGENT_CONTEXT_FINGERPRINT_MAX_BYTES = 1024;
@@ -34,7 +33,9 @@ async function inspectDeveloperContextExecutor(options, workspaceRoot, dependenc
     };
 }
 function serializeDeveloperAgentContextFingerprint(context) {
-    const canonicalContext = (0, validation_js_1.serializeDeveloperAgentContext)(context);
+    // The fingerprint binds the emitted (byte-bounded) context, the same bytes
+    // `ebk agent context --json` returns.
+    const canonicalContext = (0, context_js_1.serializeDeveloperAgentContextForTransport)(context).serialized;
     const fingerprint = {
         canonicalContextBytes: node_buffer_1.Buffer.byteLength(canonicalContext, 'utf8'),
         canonicalContextDigest: `sha256:${(0, node_crypto_1.createHash)('sha256')
@@ -53,8 +54,7 @@ function serializeDeveloperAgentContextFingerprint(context) {
 function renderDeveloperContextExecutorOutput(context, json) {
     if (json)
         return serializeDeveloperAgentContextFingerprint(context);
-    (0, validation_js_1.serializeDeveloperAgentContext)(context);
-    return (0, context_js_1.formatDeveloperAgentContext)(context);
+    return (0, context_js_1.formatDeveloperAgentContext)((0, context_js_1.serializeDeveloperAgentContextForTransport)(context).context);
 }
 async function executeDeveloperContextExecutor(options, workspaceRoot, dependencies = {}) {
     const result = await inspectDeveloperContextExecutor(options, workspaceRoot, dependencies);

package/src/generators/preset/workspace-files-adopter-skills.js

@@ -45,7 +45,17 @@ Read \`AGENTS.md\`, \`docs/architecture.md\` and the user's requested acceptance
 Run \`pnpm nx run ${name}:work-markers\`, then narrow discovery to the relevant
 Slice: \`ebk agent context --projects billing --json\` (replace billing with an
 actual project). Use \`--slice=billing --feature=<registered-id>\` when relevant.
-Without a known owner, inspect the project list first; do not read every target.
+For cross-Slice work, name exactly the Slices in scope, such as
+\`--projects=billing,notifications\`. Without a known owner, inspect the project
+list first; do not read every target.
+
+The emitted context has a fixed byte bound. A full-workspace context, run
+without \`--projects\`, can exceed it in a workspace with three or more Slices.
+An overflow fails as \`tool-internal-error\` and reports the byte counts. It is
+not a missing prerequisite: narrow \`--projects\` instead of repairing installs,
+stores or worktrees. When many linked worktrees exist, the emitted list of
+concurrent changes may be truncated (\`concurrentChangesTruncated\`); \`ebk agent
+plan\` still checks overlaps against the complete list.
 
 Find its \`.ebk/ownership.json\`, feature registry, published contracts and
 \`project.json\`. Managed mechanics change through their owning generator;

package/src/generators/preset/workspace-files-developer-agent.js

@@ -143,9 +143,13 @@ or IDE command) that only invokes these same commands with \`--json\` is permitt
 ## Canonical loop
 
 1. Run \`pnpm nx run ${name}:work-markers\`.
-2. Run \`ebk agent context\` to inspect bounded repository, Git, project, ownership, policy,
-   marker, contract, and verification facts. Select an explicit base and head when affected
-   calculation is required. This CLI is the sole full structured context transport. The root
+2. Run \`ebk agent context --projects=<slice[,slice]>\`, naming the Slices in scope, to inspect
+   bounded repository, Git, project, ownership, policy, marker, contract, and verification
+   facts. A full-workspace context without \`--projects\` can exceed the fixed context byte
+   bound in a workspace with three or more Slices; that fails as \`tool-internal-error\` with
+   the byte counts and is fixed by narrowing the selection, not by repairing local setup.
+   Select an explicit base and head when affected calculation is required.
+   This CLI is the sole full structured context transport. The root
    \`pnpm nx run ${name}:developer-context\` target is a compatibility and graph-authority
    route: its human mode emits concise prose, and \`--json\` emits only the canonical context
    byte length and digest in a bounded fingerprint.
@@ -282,7 +286,12 @@ or prerequisite-layer drift remains blocking. Prerelease consumers regenerate cl
 instead of using this stable-line transition as beta compatibility.
 
 Bound inspection with \`--projects=<names>\`, \`--slice=<name>\`, and optional
-\`--feature=<name>\`. Affected inspection requires the complete
+\`--feature=<name>\`. The emitted JSON context is at most 128 KiB. When linked worktrees
+carry more concurrent changes than fit, it keeps those under the selected projects,
+root-level files and \`.ebk/\` first, and reports \`concurrentChangeCount\`,
+\`concurrentChangesDigest\` and \`concurrentChangesTruncated\` for the complete list.
+\`ebk agent plan\`, \`ebk agent upgrade-preview\` and \`ebk agent resume\` always use the
+complete in-process list. Affected inspection requires the complete
 \`--base=<ref> --head=<ref>\` pair; \`--targets=<names>\` is valid only with that pair.
 Reference an existing generated or separately retained candidate document explicitly with
 \`--candidate-provenance=<workspace-relative-path>\`; context records only its path and

package/src/generators/preset/workspace-files.js

@@ -167,7 +167,7 @@ const TOOL_VERSIONS = {
     eslintPluginJsxA11y: '6.10.2',
     globals: '^16.0.0',
     nodeTypes: '25.5.0',
-    nx: '23.1.0',
+    nx: '23.2.1',
     pnpm: tool_versions_js_1.WORKSPACE_PNPM_VERSION,
     prettier: '^3.8.2',
     pulumiRandom: '4.21.1',

package/src/generators/slice/built-in-plan-shared.d.ts

@@ -15,9 +15,9 @@ export declare const PRODUCT_VERSIONS: {
     readonly awsSqs: "^3.700.0";
     readonly awsSsm: "^3.700.0";
     readonly awsSts: "^3.700.0";
-    readonly drizzle: "^0.45.1";
+    readonly drizzle: "^0.45.2";
     readonly drizzleKit: "^0.31.4";
-    readonly next: "16.3.4";
+    readonly next: "16.3.6";
     readonly pg: "^8.22.0";
     readonly playwright: "^1.59.1";
     readonly react: "19.2.8";

package/src/generators/slice/built-in-plan-shared.js

@@ -25,9 +25,9 @@ exports.PRODUCT_VERSIONS = {
     awsSqs: '^3.700.0',
     awsSsm: '^3.700.0',
     awsSts: '^3.700.0',
-    drizzle: '^0.45.1',
+    drizzle: '^0.45.2',
     drizzleKit: '^0.31.4',
-    next: '16.3.4',
+    next: '16.3.6',
     pg: '^8.22.0',
     playwright: '^1.59.1',
     react: '19.2.8',

package/src/git-policy/action-pins.d.ts

@@ -1,8 +1,8 @@
 export declare const GITHUB_ACTION_PINS: {
     readonly cache: {
         readonly action: "actions/cache";
-        readonly sha: "0057852bfaa89a56745cba8c7296529d2fc39830";
-        readonly tag: "v4.3.0";
+        readonly sha: "caa296126883cff596d87d8935842f9db880ef25";
+        readonly tag: "v5.1.0";
     };
     readonly checkout: {
         readonly action: "actions/checkout";

package/src/git-policy/action-pins.js

@@ -5,8 +5,8 @@ exports.pinnedAction = pinnedAction;
 exports.GITHUB_ACTION_PINS = {
     cache: {
         action: 'actions/cache',
-        sha: '0057852bfaa89a56745cba8c7296529d2fc39830',
-        tag: 'v4.3.0',
+        sha: 'caa296126883cff596d87d8935842f9db880ef25',
+        tag: 'v5.1.0',
     },
     checkout: {
         action: 'actions/checkout',

package/src/local-dev/fleet-client.js

@@ -47,7 +47,7 @@ function validateOperation(value) {
             : '/validation/.git',
         heartbeatAt: '1970-01-01T00:00:00.000Z',
         identitySource: 'worktree-task',
-        nxVersion: '23.1.0',
+        nxVersion: '23.2.1',
         operations: [value],
         origin: 'https://validation.ebk.localhost',
         resolvedStage: 'personal-validation',