@nexusclawhq/cli 0.2.1

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/cli-contract.types.d.ts

@@ -0,0 +1,140 @@
+/**
+ * CLI machine command-contract, execution-mode and result types.
+ *
+ * Frozen by executable-asset design §16.1 (command metadata / modes) and §16.2
+ * (machine result). Human `--help`, machine `ai help --json`, scaffold and
+ * validators are all generated from ONE command-contract registry (R-14). The
+ * registry is owned by the CLI package; these types are the shared import
+ * surface consumed by backend guard parity checks as well.
+ */
+import { CLI_COMMAND_CONTRACT_SCHEMA_VERSION, CLI_RESULT_SCHEMA_VERSION } from './contract-versions';
+import type { JsonValue } from './json-value';
+export type CliExitCode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 64 | 70;
+export type CliArgvSchemaMatcher = 'uuid' | 'sha256' | 'positive_integer';
+export type CliArgvPredicateAtomV1 = {
+    kind: 'option_present' | 'option_absent';
+    option: string;
+} | {
+    kind: 'option_equals';
+    option: string;
+    value: string | number | boolean;
+} | {
+    kind: 'option_matches_schema';
+    option: string;
+    matcher: CliArgvSchemaMatcher;
+} | {
+    kind: 'exactly_one' | 'none_of';
+    options: string[];
+};
+export type CliArgvPredicateExprV1 = CliArgvPredicateAtomV1 | {
+    kind: 'all_of' | 'any_of';
+    expressions: CliArgvPredicateExprV1[];
+} | {
+    kind: 'not';
+    expression: CliArgvPredicateExprV1;
+};
+export type CliPermissionFactV1 = 'surface_contains_flow' | 'verified_context_contains_flow' | 'safe_bundle_inventory_contains_flow' | 'direct_flow_selector' | 'authoritative_candidate_contains_flow' | 'authoritative_transition_contains_flow';
+export interface CliPermissionRuleV1 {
+    readonly when: 'always' | CliPermissionFactV1;
+    readonly require: ReadonlyArray<{
+        capability: string;
+        action: string;
+    }>;
+}
+/** Exact permission profile enum (design §16.1). */
+export type CliPermissionProfileId = 'LOCAL' | 'CONTEXT_READ' | 'BUNDLE_READ' | 'CANDIDATE_TEST' | 'BUNDLE_STAGE' | 'BUNDLE_GATE' | 'BUNDLE_PROMOTE' | 'BUNDLE_REVOKE';
+/** Exact effect enum; `['none']` cannot coexist with another effect. */
+export type CliEffectKind = 'none' | 'local_write' | 'remote_read' | 'remote_compute' | 'remote_write' | 'promote';
+export interface CliArgumentContract {
+    readonly name: string;
+    readonly required: boolean;
+    readonly description: string;
+}
+export interface CliOptionContract {
+    readonly name: string;
+    readonly description: string;
+    readonly required: boolean;
+    readonly default?: boolean;
+}
+export interface CliExecutionModeV1 {
+    readonly modeId: string;
+    readonly when: CliArgvPredicateExprV1;
+    readonly auth: 'none' | 'org';
+    readonly effects: ReadonlyArray<CliEffectKind>;
+    readonly permissionProfileId: CliPermissionProfileId;
+    readonly permissionRules: ReadonlyArray<CliPermissionRuleV1>;
+    readonly requiresCanDevelop: boolean;
+    readonly requiresStepUp: boolean;
+    readonly requiresIdempotencyKey: boolean;
+    readonly availability: 'planned' | 'implemented' | 'disabled';
+    readonly implementationId: string | null;
+}
+export interface CliCommandContractV1 {
+    readonly schemaVersion: typeof CLI_COMMAND_CONTRACT_SCHEMA_VERSION;
+    readonly commandId: string;
+    readonly path: string;
+    readonly aliases: ReadonlyArray<string>;
+    readonly summary: string;
+    readonly arguments: ReadonlyArray<CliArgumentContract>;
+    readonly options: ReadonlyArray<CliOptionContract>;
+    readonly inputSchemaRefs: ReadonlyArray<string>;
+    readonly outputSchemaRef: string;
+    readonly executionModes: ReadonlyArray<CliExecutionModeV1>;
+    readonly exitCodes: ReadonlyArray<CliExitCode>;
+    readonly examples: ReadonlyArray<{
+        readonly argv: ReadonlyArray<string>;
+        readonly purpose: string;
+        readonly modeId: string;
+    }>;
+    readonly nextCommands: ReadonlyArray<{
+        readonly commandId: string;
+        readonly whenModeIds: ReadonlyArray<string>;
+        readonly authorization: 'none' | 'explicit_user';
+    }>;
+    readonly contractCompleteness: 'complete' | 'derived' | 'partial';
+}
+export interface CliDiagnosticV1 {
+    readonly code: string;
+    readonly severity: 'error' | 'warning' | 'info';
+    readonly phase: string;
+    readonly artifactId?: string;
+    readonly file?: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly jsonPath?: string;
+    readonly ruleId?: string;
+    readonly message: string;
+    readonly fixHint?: string;
+    readonly retryable: boolean;
+    readonly docsRef?: string;
+}
+export interface CliNextCommandV1 {
+    readonly command: string;
+    readonly reason: string;
+    readonly authorization: 'none' | 'explicit_user';
+    readonly requiresReleaseApproval: boolean;
+}
+export interface CliEvidenceEntryV1 {
+    readonly kind: string;
+    readonly id?: string;
+    readonly path?: string;
+    readonly digest?: string;
+}
+/**
+ * The single `--json` stdout document. JSON mode forbids spinner/color/banner
+ * or human prose on stdout; stderr must be empty after the JSON renderer is
+ * established. Exit precedence when multiple diagnostics: 70 > 3 > 2 > 4 > 5 >
+ * 6 > 1.
+ */
+export interface CliResultV1<T extends JsonValue = JsonValue> {
+    readonly schemaVersion: typeof CLI_RESULT_SCHEMA_VERSION;
+    readonly ok: boolean;
+    readonly exitCode: CliExitCode;
+    readonly command: string;
+    readonly phase: string;
+    readonly contractVersion: string;
+    readonly data: T | null;
+    readonly diagnostics: ReadonlyArray<CliDiagnosticV1>;
+    readonly evidence: ReadonlyArray<CliEvidenceEntryV1>;
+    readonly nextCommands: ReadonlyArray<CliNextCommandV1>;
+}

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/cli-contract.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=cli-contract.types.js.map

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/cli-contract.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-contract.types.js","sourceRoot":"","sources":["../../src/agent-executable-assets/cli-contract.types.ts"],"names":[],"mappings":""}

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/code-action.types.d.ts

@@ -0,0 +1,278 @@
+/**
+ * Action handler ABI, tool catalog descriptor and runtime SDK contracts.
+ *
+ * Every field here is frozen by executable-asset design §6.2 (catalog/export),
+ * §7.1 (ABI), §8.1-8.5 (SDK) and §10.3 (descriptor checksum). Do not rename,
+ * retype or add fields without a contract-version change. The backend and CLI
+ * MUST import these types from `@nexusclaw/shared` and MUST NOT redeclare them.
+ */
+import type { JsonValue } from './json-value';
+import { ACTION_CONTRACT_VERSION, AGENT_CODE_TOOL_EXPORT_SCHEMA_VERSION, RUNTIME_API_VERSION_V2, VERIFIED_ISOLATE_PROVIDER_ID } from './contract-versions';
+/**
+ * Canonical decimal amount as a string. Regex `0|[1-9][0-9]*(\.[0-9]{1,9})?`
+ * — no float money, no leading zeros, no exponent.
+ */
+export type DecimalMoneyAmount = string;
+/** ISO-4217 uppercase currency code. */
+export type CurrencyCode = string;
+/** Pricing version stamp; required on every AI cost return (design §8.4). */
+export type PricingVersion = string;
+export type ActionRiskLevel = 'L0' | 'L1' | 'L2' | 'L3' | 'L4';
+export type SideEffectMode = 'pure' | 'read_only' | 'idempotent_write' | 'side_effecting';
+/** Records CRUD operations a capability may declare. */
+export type RecordsOperation = 'read' | 'create' | 'update' | 'delete';
+/**
+ * One Agent/Flow-callable export in a code-extension package. Frozen as
+ * `agent-code-tool/v1`. Fields enter the descriptor/source lock checksums.
+ */
+export interface AgentCodeToolExportV1 {
+    readonly contractVersion: typeof AGENT_CODE_TOOL_EXPORT_SCHEMA_VERSION;
+    readonly actionContractVersion: typeof ACTION_CONTRACT_VERSION;
+    /** Stable export identifier; resolves to `extensionId` in the manifest. */
+    readonly exportId: string;
+    /** Manifest `executableArtifacts[].extensionId` this export binds to. */
+    readonly artifactRef: string;
+    /** Granular tool name `custom.<namespace>.<action>`. */
+    readonly toolName: `custom.${string}.${string}`;
+    readonly description: string;
+    /** Package-local input schema ref (Draft 2020-12). */
+    readonly inputSchemaRef: string;
+    /** Package-local output schema ref (Draft 2020-12). */
+    readonly outputSchemaRef: string;
+    readonly sideEffectMode: SideEffectMode;
+    readonly declaredRiskLevel: ActionRiskLevel;
+    readonly capabilities: {
+        readonly records: ReadonlyArray<{
+            readonly objectApiName: string;
+            readonly operations: ReadonlyArray<RecordsOperation>;
+            readonly readFields?: ReadonlyArray<string>;
+            readonly writeFields?: ReadonlyArray<string>;
+        }>;
+        readonly connectors: ReadonlyArray<{
+            readonly bindingKey: string;
+            readonly operations: ReadonlyArray<string>;
+        }>;
+        readonly ai: ReadonlyArray<{
+            readonly policyKey: string;
+            readonly outputSchemaRef: string;
+        }>;
+    };
+    readonly limits: {
+        readonly timeoutMs: number;
+        readonly memoryMb: 128;
+        readonly maxQueries: number;
+        readonly maxDmlStatements: number;
+        readonly maxDmlRows: number;
+        readonly maxCallouts: number;
+        readonly maxAiCalls: number;
+        readonly maxAiInputTokens: number;
+        readonly maxAiOutputTokens: number;
+        readonly maxAiCost: {
+            readonly amount: DecimalMoneyAmount;
+            readonly currency: CurrencyCode;
+        };
+        readonly maxLogEntries: number;
+        readonly maxLogBytes: number;
+        readonly maxAttempts: 1;
+    };
+    readonly idempotency?: {
+        readonly inputJsonPointer: string;
+        readonly windowSeconds: 86400;
+    };
+    readonly redaction: {
+        readonly inputJsonPointers: ReadonlyArray<string>;
+        readonly outputJsonPointers: ReadonlyArray<string>;
+        readonly logPolicy: 'metadata_only' | 'redacted_payload';
+    };
+    readonly tests: ReadonlyArray<{
+        readonly path: string;
+        readonly required: true;
+    }>;
+}
+/**
+ * Sidecar catalog referenced by manifest `agentToolCatalogPath`. Frozen as
+ * `agent-code-tool-catalog/v1`. Export array order is normalised by exportId
+ * before any digest (design §10.3).
+ */
+export interface AgentCodeToolCatalogV1 {
+    readonly schemaVersion: 'agent-code-tool-catalog/v1';
+    readonly packageName: string;
+    readonly packageVersion: string;
+    readonly exports: ReadonlyArray<AgentCodeToolExportV1>;
+}
+/**
+ * Runtime composition of an export with release/revision/provider stamps. Adds
+ * NO export fields — it composes {@link AgentCodeToolExportV1} (design §5.6,
+ * §6.2). This is the workspace-scoped descriptor resolved by ToolRegistry.
+ */
+export interface ResolvedAgentExecutableToolV1 {
+    readonly sourceWorkspaceId: string;
+    readonly executionWorkspaceId: string;
+    readonly releaseSetId: string;
+    readonly functionRevisionId: string;
+    readonly sourceHash: `sha256:${string}`;
+    readonly compiledHash: `sha256:${string}`;
+    readonly descriptorHash: `sha256:${string}`;
+    readonly publishedChecksum: `sha256:${string}`;
+    readonly runtimeProviderId: typeof VERIFIED_ISOLATE_PROVIDER_ID;
+    readonly exportDescriptor: Readonly<AgentCodeToolExportV1>;
+}
+export interface CodeActionPrincipalV1 {
+    readonly workspaceId: string;
+    readonly agentId: string;
+    readonly agentVersionId: string;
+    readonly serviceIdentityId: string;
+    readonly roleId: string;
+    readonly orgNodeId?: string;
+    readonly triggeredByUserId?: string;
+    readonly executionKind: 'agent' | 'flow';
+    readonly executionId: string;
+    readonly releaseSetId: string;
+    readonly traceId: string;
+    readonly correlationId: string;
+}
+/**
+ * The frozen host-injected facade exposed inside the verified isolate. Legacy
+ * runtime/v1 namespaces (`http`/`email`/`events`) NEVER appear on v1 actions
+ * (design §1.4, §8). Only records/connectors/ai/clock/limits/logger cross.
+ */
+export interface CodeActionContextV1 {
+    readonly principal: CodeActionPrincipalV1;
+    readonly records: CodeRecordsV1;
+    readonly connectors: CodeConnectorsV1;
+    readonly ai: CodeAiV1;
+    readonly clock: {
+        readonly executionStartedAt: string;
+    };
+    readonly limits: CodeLimitsV1;
+    readonly logger: CodeLoggerV1;
+}
+/** The single v1 handler ABI: default export assignable to this. */
+export type CodeAction<TInput extends JsonValue, TOutput extends JsonValue> = (ctx: CodeActionContextV1, input: TInput) => Promise<TOutput>;
+export type RecordScalar = string | number | boolean | null;
+export type RecordFilterV1 = {
+    op: 'and' | 'or';
+    filters: RecordFilterV1[];
+} | {
+    op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte';
+    field: string;
+    value: RecordScalar;
+} | {
+    op: 'in' | 'not_in';
+    field: string;
+    values: RecordScalar[];
+} | {
+    op: 'contains' | 'starts_with' | 'ends_with';
+    field: string;
+    value: string;
+} | {
+    op: 'is_null' | 'is_not_null';
+    field: string;
+};
+export interface CodeRecordsV1 {
+    get(args: {
+        objectApiName: string;
+        recordId: string;
+        select: string[];
+    }): Promise<{
+        id: string;
+        version: number;
+        values: Record<string, JsonValue>;
+    } | null>;
+    query(args: {
+        objectApiName: string;
+        select: string[];
+        where?: RecordFilterV1;
+        orderBy?: ReadonlyArray<{
+            field: string;
+            direction: 'asc' | 'desc';
+            nulls: 'first' | 'last';
+        }>;
+        first: number;
+        after?: string;
+    }): Promise<{
+        nodes: ReadonlyArray<{
+            id: string;
+            version: number;
+            values: Record<string, JsonValue>;
+        }>;
+        pageInfo: {
+            endCursor?: string;
+            hasNextPage: boolean;
+        };
+    }>;
+    create(args: {
+        objectApiName: string;
+        values: Record<string, JsonValue>;
+    }): Promise<{
+        id: string;
+        version: number;
+    }>;
+    update(args: {
+        objectApiName: string;
+        recordId: string;
+        values: Record<string, JsonValue>;
+        expectedVersion: number;
+    }): Promise<{
+        id: string;
+        version: number;
+    }>;
+    delete(args: {
+        objectApiName: string;
+        recordId: string;
+        expectedVersion: number;
+    }): Promise<{
+        id: string;
+        recycled: true;
+    }>;
+}
+export interface CodeConnectorsV1 {
+    call<TInput extends JsonValue, TOutput extends JsonValue>(args: {
+        bindingKey: string;
+        operation: string;
+        input: TInput;
+    }): Promise<{
+        data: TOutput;
+        operationId: string;
+        status: 'succeeded';
+    }>;
+}
+export interface CodeAiGenerateUsageV1 {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cost: {
+        readonly amount: DecimalMoneyAmount;
+        readonly currency: CurrencyCode;
+        readonly pricingVersion: PricingVersion;
+    };
+}
+export interface CodeAiGenerateResultV1<T extends JsonValue> {
+    readonly data: T;
+    readonly modelAlias: string;
+    readonly usage: CodeAiGenerateUsageV1;
+    readonly invocationId: string;
+    readonly providerStamp: {
+        readonly providerClass: string;
+        readonly routePolicyRevisionId: string;
+        readonly fallbackIndex: number;
+    };
+}
+export interface CodeAiV1 {
+    generate<T extends JsonValue>(args: {
+        policyKey: string;
+        input: JsonValue;
+        outputSchemaRef: string;
+        maxOutputTokens?: number;
+    }): Promise<CodeAiGenerateResultV1<T>>;
+}
+export interface CodeLoggerV1 {
+    debug(event: string, fields?: Record<string, JsonValue>): void;
+    info(event: string, fields?: Record<string, JsonValue>): void;
+    warn(event: string, fields?: Record<string, JsonValue>): void;
+    error(event: string, fields?: Record<string, JsonValue>): void;
+}
+export interface CodeLimitsV1 {
+    getUsage(): Readonly<Record<string, number>>;
+    getLimit(): Readonly<Record<string, number>>;
+}
+export { ACTION_CONTRACT_VERSION, RUNTIME_API_VERSION_V2, VERIFIED_ISOLATE_PROVIDER_ID, };

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/code-action.types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERIFIED_ISOLATE_PROVIDER_ID = exports.RUNTIME_API_VERSION_V2 = exports.ACTION_CONTRACT_VERSION = void 0;
+const contract_versions_1 = require("./contract-versions");
+Object.defineProperty(exports, "ACTION_CONTRACT_VERSION", { enumerable: true, get: function () { return contract_versions_1.ACTION_CONTRACT_VERSION; } });
+Object.defineProperty(exports, "RUNTIME_API_VERSION_V2", { enumerable: true, get: function () { return contract_versions_1.RUNTIME_API_VERSION_V2; } });
+Object.defineProperty(exports, "VERIFIED_ISOLATE_PROVIDER_ID", { enumerable: true, get: function () { return contract_versions_1.VERIFIED_ISOLATE_PROVIDER_ID; } });
+//# sourceMappingURL=code-action.types.js.map

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/code-action.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-action.types.js","sourceRoot":"","sources":["../../src/agent-executable-assets/code-action.types.ts"],"names":[],"mappings":";;;AASA,2DAK6B;AAwS3B,wGA5SA,2CAAuB,OA4SA;AACvB,uGA3SA,0CAAsB,OA2SA;AACtB,6GA3SA,gDAA4B,OA2SA"}

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/code-extension-manifest.types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Code-extension manifest v2 governance + ACTION artifact entry contracts
+ * (executable-asset design §6.1, task 3.1).
+ *
+ * The v1/v2 discriminant is the enclosing `codeExtensionGovernance.contractVersion`:
+ *  - `code-extension-governance/v1`: legacy behavior unchanged (optional id,
+ *    trigger kind allowed, no Agent binding).
+ *  - `code-extension-governance/v2`: required `extensionId`, ACTION-only,
+ *    `entrypoint: 'default'`, `actionContractVersion`, `runtimeApiVersion`, and
+ *    `agentToolCatalogPath`; legacy `worker-thread-hardened-isolate` never
+ *    matches (the manifest value must be exactly `nexusclaw-verified-isolate-v1`).
+ */
+import { CODE_EXTENSION_GOVERNANCE_V1, CODE_EXTENSION_GOVERNANCE_V2, ACTION_CONTRACT_VERSION, RUNTIME_API_VERSION_V2, VERIFIED_ISOLATE_PROVIDER_ID } from './contract-versions';
+/** Legacy v1 governance contract (kept compatible; no Agent binding). */
+export interface CodeExtensionGovernanceV1 {
+    readonly contractVersion: typeof CODE_EXTENSION_GOVERNANCE_V1;
+}
+/**
+ * v2 governance contract. `runtimeApiVersion` selects runtime/v2 (the
+ * verified-isolate provider surface). Permits `agentToolCatalogPath`.
+ */
+export interface CodeExtensionGovernanceV2 {
+    readonly contractVersion: typeof CODE_EXTENSION_GOVERNANCE_V2;
+    readonly runtimeApiVersion: typeof RUNTIME_API_VERSION_V2;
+}
+export type CodeExtensionGovernance = CodeExtensionGovernanceV1 | CodeExtensionGovernanceV2;
+/**
+ * Legacy v1 code-executable artifact entry. Optional id; trigger kind allowed;
+ * `dependsOn` may describe a runtime graph.
+ */
+export interface LegacyCodeExecutableArtifactManifestEntryV1 {
+    readonly extensionId?: string;
+    readonly apiName?: string;
+    readonly kind: 'function' | 'trigger';
+    readonly functionType?: string;
+    readonly sourcePath: string;
+    readonly entrypoint?: string;
+    readonly dependsOn?: ReadonlyArray<string>;
+}
+/**
+ * v2 ACTION artifact entry (design §6.1, verbatim). Required `extensionId`,
+ * ACTION-only, default entrypoint, frozen contract + runtime versions.
+ */
+export interface CodeExecutableActionArtifactManifestEntryV2 {
+    /** Required stable artifactRef target (catalog `artifactRef` must equal this). */
+    readonly extensionId: string;
+    readonly apiName: string;
+    readonly kind: 'function';
+    readonly functionType: 'ACTION';
+    readonly sourcePath: string;
+    readonly entrypoint: 'default';
+    readonly actionContractVersion: typeof ACTION_CONTRACT_VERSION;
+    readonly runtimeApiVersion: typeof RUNTIME_API_VERSION_V2;
+    /** Single-file v1 has no runtime graph. */
+    readonly dependsOn?: never;
+}
+export type CodeExecutableArtifactManifestEntry = LegacyCodeExecutableArtifactManifestEntryV1 | CodeExecutableActionArtifactManifestEntryV2;
+/**
+ * Type guard: is the artifact entry a v2 ACTION entry?
+ */
+export declare function isV2ActionEntry(entry: CodeExecutableArtifactManifestEntry): entry is CodeExecutableActionArtifactManifestEntryV2;
+/** The runtime provider requirement a v2 manifest must declare. */
+export declare const V2_RUNTIME_PROVIDER_REQUIREMENT: "nexusclaw-verified-isolate-v1";
+/** Re-exported version literals for convenience. */
+export { CODE_EXTENSION_GOVERNANCE_V1, CODE_EXTENSION_GOVERNANCE_V2, ACTION_CONTRACT_VERSION, RUNTIME_API_VERSION_V2, VERIFIED_ISOLATE_PROVIDER_ID, };

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/code-extension-manifest.types.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERIFIED_ISOLATE_PROVIDER_ID = exports.RUNTIME_API_VERSION_V2 = exports.ACTION_CONTRACT_VERSION = exports.CODE_EXTENSION_GOVERNANCE_V2 = exports.CODE_EXTENSION_GOVERNANCE_V1 = exports.V2_RUNTIME_PROVIDER_REQUIREMENT = void 0;
+exports.isV2ActionEntry = isV2ActionEntry;
+/**
+ * Code-extension manifest v2 governance + ACTION artifact entry contracts
+ * (executable-asset design §6.1, task 3.1).
+ *
+ * The v1/v2 discriminant is the enclosing `codeExtensionGovernance.contractVersion`:
+ *  - `code-extension-governance/v1`: legacy behavior unchanged (optional id,
+ *    trigger kind allowed, no Agent binding).
+ *  - `code-extension-governance/v2`: required `extensionId`, ACTION-only,
+ *    `entrypoint: 'default'`, `actionContractVersion`, `runtimeApiVersion`, and
+ *    `agentToolCatalogPath`; legacy `worker-thread-hardened-isolate` never
+ *    matches (the manifest value must be exactly `nexusclaw-verified-isolate-v1`).
+ */
+const contract_versions_1 = require("./contract-versions");
+Object.defineProperty(exports, "CODE_EXTENSION_GOVERNANCE_V1", { enumerable: true, get: function () { return contract_versions_1.CODE_EXTENSION_GOVERNANCE_V1; } });
+Object.defineProperty(exports, "CODE_EXTENSION_GOVERNANCE_V2", { enumerable: true, get: function () { return contract_versions_1.CODE_EXTENSION_GOVERNANCE_V2; } });
+Object.defineProperty(exports, "ACTION_CONTRACT_VERSION", { enumerable: true, get: function () { return contract_versions_1.ACTION_CONTRACT_VERSION; } });
+Object.defineProperty(exports, "RUNTIME_API_VERSION_V2", { enumerable: true, get: function () { return contract_versions_1.RUNTIME_API_VERSION_V2; } });
+Object.defineProperty(exports, "VERIFIED_ISOLATE_PROVIDER_ID", { enumerable: true, get: function () { return contract_versions_1.VERIFIED_ISOLATE_PROVIDER_ID; } });
+/**
+ * Type guard: is the artifact entry a v2 ACTION entry?
+ */
+function isV2ActionEntry(entry) {
+    return (entry.kind === 'function' &&
+        entry.functionType === 'ACTION' &&
+        entry.entrypoint === 'default' &&
+        typeof entry.extensionId === 'string' &&
+        entry.extensionId.length > 0);
+}
+/** The runtime provider requirement a v2 manifest must declare. */
+exports.V2_RUNTIME_PROVIDER_REQUIREMENT = contract_versions_1.VERIFIED_ISOLATE_PROVIDER_ID;
+//# sourceMappingURL=code-extension-manifest.types.js.map

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/code-extension-manifest.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-extension-manifest.types.js","sourceRoot":"","sources":["../../src/agent-executable-assets/code-extension-manifest.types.ts"],"names":[],"mappings":";;;AA2EA,0CAUC;AArFD;;;;;;;;;;;GAWG;AACH,2DAM6B;AA0E3B,6GA/EA,gDAA4B,OA+EA;AAC5B,6GA/EA,gDAA4B,OA+EA;AAC5B,wGA/EA,2CAAuB,OA+EA;AACvB,uGA/EA,0CAAsB,OA+EA;AACtB,6GA/EA,gDAA4B,OA+EA;AAxB9B;;GAEG;AACH,SAAgB,eAAe,CAC7B,KAA0C;IAE1C,OAAO,CACL,KAAK,CAAC,IAAI,KAAK,UAAU;QACxB,KAAmC,CAAC,YAAY,KAAK,QAAQ;QAC9D,KAAK,CAAC,UAAU,KAAK,SAAS;QAC9B,OAAO,KAAK,CAAC,WAAW,KAAK,QAAQ;QACrC,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAC7B,CAAC;AACJ,CAAC;AAED,mEAAmE;AACtD,QAAA,+BAA+B,GAAG,gDAA4B,CAAC"}

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/agent-executable-assets/contract-schemas.d.ts

@@ -0,0 +1,77 @@
+/**
+ * JSON Schema (Draft 2020-12) contract objects for the executable-workforce
+ * surface, plus the frozen AJV configuration.
+ *
+ * Verbatim frozen constraints from design §9:
+ * - dialect AJV Draft 2020-12, configured as below.
+ * - every object explicitly sets `additionalProperties: false`.
+ * - no remote refs, recursive refs, patternProperties, unevaluatedProperties,
+ *   or custom executable formats; `$ref` targets must be inside `schemas/`.
+ * - limits: schema file max 256 KiB; resolved schema depth max 12; total
+ *   object properties max 256; enum values max 256; string pattern length max
+ *   512. Runtime input/output max follows descriptor hard max 1 MiB.
+ * - diagnostic path is RFC 6901 JSON Pointer; deterministic ordering
+ *   `(file, jsonPath, ruleId, code)`.
+ *
+ * These schema objects are the shared truth consumed by CLI local validation,
+ * backend preflight, and runtime input/output enforcement (R-04 rule 4).
+ */
+import type { AnySchemaObject } from 'ajv';
+/**
+ * The frozen AJV 8.18.0 configuration for Draft 2020-12 (design §9). All
+ * settings are mandatory; toggling any is a contract change.
+ */
+export declare const FROZEN_AJV_CONFIG: {
+    readonly strict: true;
+    readonly strictSchema: true;
+    readonly allErrors: true;
+    readonly allowUnionTypes: false;
+    readonly coerceTypes: false;
+    readonly useDefaults: false;
+    readonly removeAdditional: false;
+    readonly validateFormats: false;
+    readonly unicodeRegExp: true;
+    readonly messages: true;
+    readonly $data: false;
+};
+/** Frozen schema-shape limits (design §9). */
+export declare const SCHEMA_LIMITS: {
+    readonly schemaFileMaxBytes: number;
+    readonly resolvedDepthMax: 12;
+    readonly totalPropertiesMax: 256;
+    readonly enumValuesMax: 256;
+    readonly patternLengthMax: 512;
+};
+/** Canonical decimal amount regex (design §6.2): `0|[1-9][0-9]*(\.[0-9]{1,9})?`. */
+export declare const DECIMAL_MONEY_PATTERN = "^(0|[1-9][0-9]{0,17})(\\.[0-9]{1,9})?$";
+/** Uppercase ISO-4217 currency. */
+export declare const CURRENCY_PATTERN = "^[A-Z]{3}$";
+/** Tool name `custom.<namespace>.<action>`. */
+export declare const TOOL_NAME_PATTERN = "^custom\\.[a-z0-9-]+\\.[a-z0-9-]+$";
+/** Lower-case `sha256:<64 hex>`. */
+export declare const SHA256_PATTERN = "^sha256:[0-9a-f]{64}$";
+/**
+ * Root of an action input/output schema: must be `type: object` with
+ * `additionalProperties: false` (R-04 rule 2). Use as a base to compose.
+ */
+export declare const actionIoSchemaRoot: (id: string) => AnySchemaObject;
+/**
+ * `agent-code-tool/v1` export descriptor schema (design §6.2). Mirrors
+ * {@link AgentCodeToolExportV1} exactly; every object is `additionalProperties:
+ * false`.
+ */
+export declare const agentCodeToolExportSchema: AnySchemaObject;
+/** `nexusclaw.cli-result/v1` envelope schema (design §16.2 / R-17). */
+export declare const cliResultSchema: AnySchemaObject;
+/**
+ * Flow `payload/v2` INVOKE_UNIT action-setting schema fragment (design §15.2).
+ * Rejects duplicate mapping targets and ancestor/descendant overlap; the
+ * compiler enforces overlap statically, the schema enforces shape.
+ */
+export declare const flowInvokeUnitActionSettingSchema: AnySchemaObject;
+/**
+ * Workforce bundle v1 schema fragment — identity field subset (design §5.1).
+ * Full field validation lives in the bundle validator; this is the
+ * machine-readable schema for the `agentApiName` identity contract.
+ */
+export declare const workforceBundleIdentitySchema: AnySchemaObject;