@abot-ai/runtime 1.7.0 → 1.8.1

package/dist/src/runtime/long-term-memory/initial-context.js

@@ -0,0 +1,57 @@
+import { resolveRequestSteeringInbox } from "../request/request-steering.js";
+import { retrieveResponseLongTermMemory } from "./response-context.js";
+import { prepareConversationMemoryKnowledge, buildConversationMemoryAuthoringContext, canAuthorConversationMemory, projectConversationMemoryKnowledge, } from "./conversation-authoring/context.js";
+/** Prepared once as part of the existing request ledger initialization. */
+export async function prepareInitialMemory(request, restored) {
+    if (!usesInitialMemory(request))
+        return undefined;
+    if (restored !== undefined)
+        return restored;
+    request.abortSignal.throwIfAborted();
+    const steering = resolveRequestSteeringInbox(request.requestSteering).snapshot();
+    const message = await retrieveResponseLongTermMemory(request, steering);
+    request.abortSignal.throwIfAborted();
+    // EA prepares authoring targets at startup; Supervisor keeps its terminal step.
+    const knowledge = usesInitialExecutionMemory(request)
+        ? await prepareConversationMemoryKnowledge(request, steering)
+        : undefined;
+    request.abortSignal.throwIfAborted();
+    return Object.freeze({
+        ...(message ? { message: projectPersistentMemoryMessage(message) } : {}),
+        ...(knowledge ? { knowledge: projectConversationMemoryKnowledge(knowledge) } : {}),
+    });
+}
+function projectPersistentMemoryMessage(message) {
+    if (!message.attachments)
+        return message;
+    return { ...message, attachments: message.attachments.filter(isPersistentMemoryAttachment) };
+}
+function isPersistentMemoryAttachment(attachment) {
+    return attachment.toolEvidence === undefined;
+}
+function usesInitialMemory(request) {
+    if (!request.longTermMemory?.enabled)
+        return false;
+    if (request.executionPolicy.authority.id === "execution-agent-v1")
+        return true;
+    return request.executionPolicy.authority.id === "supervisor-worker-v1";
+}
+export function projectExecutionAgentMemory(request, initial, steering) {
+    if (!usesInitialExecutionMemory(request))
+        return { memoryMessage: undefined, authoringContext: undefined, authoringEnabled: false };
+    const authoringContext = initial?.knowledge
+        ? buildConversationMemoryAuthoringContext(request, steering, {
+            ...initial.knowledge, referenceTime: new Date().toISOString(),
+        })
+        : undefined;
+    return Object.freeze({
+        memoryMessage: initial?.message,
+        authoringContext,
+        authoringEnabled: canAuthorConversationMemory(request, authoringContext),
+    });
+}
+function usesInitialExecutionMemory(request) {
+    if (!request.longTermMemory?.enabled)
+        return false;
+    return request.executionPolicy.authority.id === "execution-agent-v1";
+}

package/dist/src/runtime/long-term-memory/projection.js

@@ -32,7 +32,7 @@ function serializeProjection(records) {
     return JSON.stringify({
         kind: LONG_TERM_MEMORY_MESSAGE_KIND,
         authority: "passive_reference",
-        purpose: "support_personalized_terminal_response_authoring",
+        purpose: "support_root_decisions_and_response_authoring",
         memories: records.map((record) => ({
             content: record.content,
             tags: record.tags,

package/dist/src/runtime/orchestration/role-calls/candidate-validation.js

@@ -2,7 +2,7 @@ import { isRuntimeDelegateRoleId, RUNTIME_ROOT_ROLE_ID, RUNTIME_ROLE_IDS, } from
 import { createRoleCapabilitySelectionFingerprint, normalizeRoleCapabilitySelectionProjection, } from "./capability-selection-reconsideration.js";
 import { isRoleCapabilitySelectionSupervisionState, } from "./capability-selection-supervision.js";
 import { isValidRoleCapabilitySelectionSupervision } from "./capability-selection-supervision-validation.js";
-import { validateRoleMemoryRecalls } from "./memory-recall-state-validation.js";
+import { hasInitialMemoryContext, validateRoleMemoryRecalls } from "./memory-recall-state-validation.js";
 import { isValidAdoptedModelWorkPlan } from "./work-plan-validation.js";
 import { isRoleOperationFingerprint, isRoleOperationOutcomeFingerprintForOutcome, isSameRoleOperationIdentity, replayRoleOperationSupervisionEvidence, } from "./operation-supervision.js";
 import { isIssuedRoleOperationSupervisionInterventionForRequest } from "./operation-supervision-issuance.js";
@@ -48,6 +48,7 @@ export function validateRoleCallState(state, policy) {
         !Array.isArray(state?.plans) ||
         !Array.isArray(state?.capabilityExecutions) ||
         !Array.isArray(state?.memoryRecalls) ||
+        !hasInitialMemoryContext(state?.initialMemory, policy.authority.id) ||
         !isRoleOperationSupervisionState(state?.operationSupervision) ||
         !isRoleCapabilitySelectionSupervisionState(state?.capabilitySelectionSupervision) ||
         !Number.isInteger(state?.callSequence) ||

package/dist/src/runtime/orchestration/role-calls/checkpoint-state.d.ts

@@ -1,4 +1,4 @@
 import type { RoleCallLedgerCheckpoint } from "./checkpoint-contract.js";
 import type { RoleCallPolicy, RoleCallState } from "./contracts.js";
 /** Hydrate only an admitted, parked capability; no model or reducer command replay. */
-export declare function restoreCheckpointState(checkpoint: RoleCallLedgerCheckpoint, requestId: string, policy: RoleCallPolicy): RoleCallState;
+export declare function restoreCheckpointState(checkpoint: RoleCallLedgerCheckpoint, requestId: string, policy: RoleCallPolicy, initialMemory?: RoleCallState["initialMemory"]): RoleCallState;

package/dist/src/runtime/orchestration/role-calls/checkpoint-state.js

@@ -4,14 +4,17 @@ import { validateRoleCallCandidate } from "./reducer.js";
 import { issueInitialRoleCapabilitySelectionSupervisionState } from "./capability-selection-supervision-issuance.js";
 import { restoreRoleOperationSupervisionIssuance } from "./operation-supervision-issuance.js";
 /** Hydrate only an admitted, parked capability; no model or reducer command replay. */
-export function restoreCheckpointState(checkpoint, requestId, policy) {
+export function restoreCheckpointState(checkpoint, requestId, policy, initialMemory) {
     if (!isCheckpointEnvelope(checkpoint))
         throw new Error("role_call_checkpoint_invalid");
     if (!hasCheckpointRequestIdentity(checkpoint, requestId))
         throw new Error("role_call_checkpoint_request_mismatch");
     if (!hasCheckpointPolicy(checkpoint, policy))
         throw new Error("role_call_checkpoint_policy_mismatch");
-    const state = seal(structuredClone(checkpoint.state));
+    const state = seal(structuredClone({ ...checkpoint.state,
+        ...(checkpoint.state.initialMemory === undefined && initialMemory !== undefined
+            ? { initialMemory } : {}),
+    }));
     if (!isParkedCapabilityState(state))
         throw new Error("role_call_checkpoint_not_parked");
     if (!issueInitialRoleCapabilitySelectionSupervisionState(state))

package/dist/src/runtime/orchestration/role-calls/contracts.d.ts

@@ -5,7 +5,7 @@ import type { RoleOperationFingerprint, RoleOperationOutcomeFingerprint, RoleOpe
 import type { RoleCapabilitySelectionSupervisionStage, RoleCapabilitySelectionSupervisionState, RoleCapabilitySelectionSupervisionTrigger } from "./capability-selection-supervision.js";
 import type { RoleCapabilitySelectionReconsiderationCause } from "./reconsideration-cause.js";
 import type { RoleCallResultReceipt } from "./result-receipt.js";
-import type { RoleMemoryRecall, RoleMemoryRecallCommand, RoleMemoryRecallCommitEffect, RoleMemoryRecallTransactions } from "./memory-recall-contract.js";
+import type { RoleInitialMemory, RoleMemoryRecall, RoleMemoryRecallCommand, RoleMemoryRecallCommitEffect, RoleMemoryRecallTransactions } from "./memory-recall-contract.js";
 import type { AdoptedModelWorkPlan, UpdateModelWorkPlanCommand, ModelWorkPlanCommitEffect, ModelWorkPlanTransactions } from "./work-plan-contracts.js";
 export declare const ROLE_CALL_LEDGER_CONTRACT_VERSION = 18;
 export declare const ROLE_CALL_LEDGER_HEAD_KIND: "runtime_role_call_ledger_v18";
@@ -191,6 +191,7 @@ export type RoleCallState = Readonly<{
     plans: readonly RoleCallPlanState[];
     capabilityExecutions: readonly RoleCapabilityExecution[];
     memoryRecalls: readonly RoleMemoryRecall[];
+    initialMemory?: RoleInitialMemory;
     operationSupervision: RoleOperationSupervisionState;
     capabilitySelectionSupervision: RoleCapabilitySelectionSupervisionState;
     rootResponse: string | null;

package/dist/src/runtime/orchestration/role-calls/ledger.d.ts

@@ -1,9 +1,10 @@
 import type { RoleCallLedgerCheckpoint } from "./checkpoint-contract.js";
-import { type RoleCallLedger, type RoleCallLedgerHead, type RoleCallPolicyInput } from "./contracts.js";
+import { type RoleCallLedger, type RoleCallLedgerHead, type RoleCallPolicyInput, type RoleCallState } from "./contracts.js";
 export declare function createRoleCallLedger(params: {
     requestId: string;
     policy: RoleCallPolicyInput;
     checkpoint?: RoleCallLedgerCheckpoint;
+    initialMemory?: RoleCallState["initialMemory"];
 }): RoleCallLedger;
 /** Confirms exact current-head ownership without trusting structural ledgers. */
 export declare function isCurrentRoleCallLedgerHead(ledger: RoleCallLedger, head: RoleCallLedgerHead): boolean;

package/dist/src/runtime/orchestration/role-calls/ledger.js

@@ -15,8 +15,8 @@ const issuedRoleCallLedgerHeads = new WeakMap();
 export function createRoleCallLedger(params) {
     const policy = sealRoleCallPolicy(params.policy);
     const initialState = params.checkpoint
-        ? restoreCheckpointState(params.checkpoint, params.requestId, policy)
-        : createInitialRoleCallState(params.requestId);
+        ? restoreCheckpointState(params.checkpoint, params.requestId, policy, params.initialMemory)
+        : createInitialRoleCallState(params.requestId, params.initialMemory);
     const capabilitySelectionSupervisionIssuanceAuthority = resolveRoleCapabilitySelectionSupervisionIssuanceAuthority(initialState);
     if (!capabilitySelectionSupervisionIssuanceAuthority) {
         throw new Error("role_call_capability_selection_supervision_issuance_authority_missing");

package/dist/src/runtime/orchestration/role-calls/memory-recall-contract.d.ts

@@ -1,3 +1,5 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { LearningKnowledgeContext } from "../../long-term-memory/maturation/contracts.js";
 import type { LongTermMemoryRecord } from "../../long-term-memory/contracts.js";
 import type { RoleCallTransactionInput, RoleCallTransactionResult } from "./contracts.js";
 export declare const ROLE_MEMORY_RECALL_QUERY_MAX_LENGTH = 1024;
@@ -49,3 +51,8 @@ export type RoleMemoryRecallTransactions = Readonly<{
     beginMemoryRecall(input: RoleCallTransactionInput<BeginRoleMemoryRecallCommand>): Promise<RoleCallTransactionResult<"memory_recall_begun", "memory_recall_transition_invalid">>;
     settleMemoryRecall(input: RoleCallTransactionInput<SettleRoleMemoryRecallCommand>): Promise<RoleCallTransactionResult<"memory_recall_settled", "memory_recall_transition_invalid">>;
 }>;
+/** Initial automatic reference; never a model recall or an activation. */
+export type RoleInitialMemory = Readonly<{
+    message?: ChatMessage;
+    knowledge?: LearningKnowledgeContext;
+}>;

package/dist/src/runtime/orchestration/role-calls/memory-recall-state-validation.d.ts

@@ -1,3 +1,5 @@
 import type { RoleCallState, RoleCallValidationIssue } from "./contracts.js";
 export declare function validateRoleMemoryRecalls(state: RoleCallState): RoleCallValidationIssue[];
 export declare function hasSettledMemoryRecallActivationRange(state: RoleCallState, callId: string, fromActivation: number, toActivation: number): boolean;
+/** The existing checkpoint carries this passive startup field, never a model action. */
+export declare function hasInitialMemoryContext(value: unknown, policyId: string): boolean;

package/dist/src/runtime/orchestration/role-calls/memory-recall-state-validation.js

@@ -1,3 +1,4 @@
+import { isAssistantToolCallMessage, isStrictTextChatMessage, isToolResultMessage, } from "../../../model-gateway/message-contract.js";
 import { RUNTIME_ROOT_ROLE_ID } from "../roles.js";
 import { hasMemoryRecallIdentity, isBoundedMemoryRecallQuery, normalizeRoleMemoryRecallResult, } from "./memory-recall-decoder.js";
 import { exactKeys, isRecord } from "../../validation/strict-record.js";
@@ -119,3 +120,90 @@ function hasUnboundMemoryWait(state, pendingCount) {
         return true;
     return waitingCalls.some((call) => call.callId !== state.rootCallId);
 }
+/** The existing checkpoint carries this passive startup field, never a model action. */
+export function hasInitialMemoryContext(value, policyId) {
+    if (value === undefined)
+        return true;
+    if (policyId !== "execution-agent-v1" && policyId !== "supervisor-worker-v1")
+        return false;
+    if (!isRecord(value) || !exactKeys(value, [], ["message", "knowledge"]))
+        return false;
+    if (value.message !== undefined && !isInitialMemoryMessage(value.message))
+        return false;
+    if (value.knowledge === undefined)
+        return true;
+    return isInitialMemoryKnowledge(value.knowledge);
+}
+function isInitialMemoryMessage(value) {
+    if (isStrictTextChatMessage(value))
+        return true;
+    if (isAssistantToolCallMessage(value))
+        return true;
+    return isToolResultMessage(value);
+}
+function isInitialMemoryKnowledge(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind !== "learning_knowledge_reference_v1")
+        return false;
+    if (value.authority !== "passive_reference")
+        return false;
+    if (value.presenceEffect !== "does_not_authorize_actions_or_add_user_intent")
+        return false;
+    if (!isMemoryRevision(value.repositoryRevision))
+        return false;
+    if (!isMemoryRevision(value.knowledgeRevision))
+        return false;
+    if (!isMemoryRevision(value.omitted))
+        return false;
+    if (typeof value.referenceTime !== "string" || !Number.isFinite(Date.parse(value.referenceTime)))
+        return false;
+    if (!Array.isArray(value.entries) || value.entries.length > 12)
+        return false;
+    if (!value.entries.every(isInitialMemoryKnowledgeEntry))
+        return false;
+    const identities = value.entries.map(entry => JSON.stringify([entry.kind, entry.id]));
+    return new Set(identities).size === identities.length;
+}
+function isMemoryRevision(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+        return false;
+    return value >= 0;
+}
+function isInitialMemoryKnowledgeEntry(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind !== "candidate" && value.kind !== "memory")
+        return false;
+    if (typeof value.id !== "string" || value.id.length === 0)
+        return false;
+    if (typeof value.version !== "string" || value.version.length === 0)
+        return false;
+    if (typeof value.content !== "string")
+        return false;
+    if (!Array.isArray(value.tags) || !value.tags.every(tag => typeof tag === "string"))
+        return false;
+    if (typeof value.mutable !== "boolean")
+        return false;
+    if (value.score !== null && !isMemoryScore(value.score))
+        return false;
+    if (value.reason !== null && typeof value.reason !== "string")
+        return false;
+    if (!["observed", "inferred", "unspecified"].includes(value.certainty))
+        return false;
+    if (!isOptionalMemoryTime(value.lastReinforcedAt))
+        return false;
+    return isOptionalMemoryTime(value.reconsiderAt);
+}
+function isMemoryScore(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return false;
+    return value >= 0 && value <= 100;
+}
+function isOptionalMemoryTime(value) {
+    if (value === null)
+        return true;
+    if (typeof value !== "string")
+        return false;
+    return Number.isFinite(Date.parse(value));
+}

package/dist/src/runtime/orchestration/role-calls/reducer.d.ts

@@ -1,6 +1,6 @@
 import { type RoleCallPolicy, type RoleCallPolicyInput, type RoleCallState, type RoleCallTransitionResult, type RoleCallValidationIssue } from "./contracts.js";
 export { hasRoleCallCapabilityAuthority } from "./candidate-validation.js";
-export declare function createInitialRoleCallState(requestId: string): RoleCallState;
+export declare function createInitialRoleCallState(requestId: string, initialMemory?: RoleCallState["initialMemory"]): RoleCallState;
 export declare function applyRoleCallCommand(state: RoleCallState, commandInput: unknown, policy: RoleCallPolicy, admittedHeadRevision?: number): RoleCallTransitionResult;
 export declare function validateRoleCallCandidate(params: {
     state: RoleCallState;

package/dist/src/runtime/orchestration/role-calls/reducer.js

@@ -8,7 +8,7 @@ import { issueInitialRoleCapabilitySelectionSupervisionState } from "./capabilit
 import { createInitialRoleOperationSupervisionState } from "./operation-supervision.js";
 import { reject, seal } from "./reducer-primitives.js";
 export { hasRoleCallCapabilityAuthority } from "./candidate-validation.js";
-export function createInitialRoleCallState(requestId) {
+export function createInitialRoleCallState(requestId, initialMemory) {
     const state = seal({
         contractVersion: ROLE_CALL_LEDGER_CONTRACT_VERSION,
         requestId,
@@ -23,6 +23,7 @@ export function createInitialRoleCallState(requestId) {
         plans: [],
         capabilityExecutions: [],
         memoryRecalls: [],
+        ...(initialMemory !== undefined ? { initialMemory } : {}),
         operationSupervision: createInitialRoleOperationSupervisionState(),
         capabilitySelectionSupervision: createInitialRoleCapabilitySelectionSupervisionState(),
         rootResponse: null,

package/dist/src/runtime/orchestration/worker-capabilities/contracts.d.ts

@@ -12,7 +12,7 @@ export declare const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
 export declare const WORKER_CAPABILITY_COUNT_MAX = 128;
 export declare const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export declare const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
-export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
+export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH } from "../../../capabilities/normal-invocation/contracts.js";
 export declare const WORKER_CAPABILITY_CONTROL_ENUM_MAX_VALUES = 64;
 export declare const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export declare const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;
@@ -165,6 +165,8 @@ export type WorkerCapabilityPreparedExecution = Readonly<{
     onAdmitted?(executionId: string): void;
     approvalRequest?: ToolApprovalRequest;
     applyApprovalDecision?(decision: BoundApprovalDecision): void;
+    /** Project a fenced rejection with adapter-owned lifecycle and evidence; never execute. */
+    rejectBeforeExecution?(executionId: string, code: string, message: string): WorkerCapabilityAdapterResult;
     execute(executionId: string): Promise<WorkerCapabilityAdapterResult>;
 }>;
 export type WorkerCapabilityAdapterPreparationInput<TContext> = Readonly<Omit<WorkerCapabilityAdapterExecutionInput<TContext>, "executionId"> & {

package/dist/src/runtime/orchestration/worker-capabilities/contracts.js

@@ -8,7 +8,7 @@ export const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
 export const WORKER_CAPABILITY_COUNT_MAX = 128;
 export const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
-export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
+export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH } from "../../../capabilities/normal-invocation/contracts.js";
 export const WORKER_CAPABILITY_CONTROL_ENUM_MAX_VALUES = 64;
 export const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;

package/dist/src/runtime/orchestration/worker-capabilities/execution/approval-group.js

@@ -1,3 +1,4 @@
+import { fenceRestoredApprovalExecution } from "./execution-freshness.js";
 import { restorePreparationRejection } from "./preparation-rejection.js";
 import { isDeepStrictEqual } from "node:util";
 import { settleAdmittedPreparedGroup } from "./settle-prepared.js";
@@ -132,7 +133,10 @@ export async function restoreCapabilityApprovalGroup(params) {
                 ledger: params.ledger,
                 expectedHead: head,
                 call,
-                invocations,
+                invocations: invocations.map((invocation) => ({
+                    ...invocation,
+                    prepared: fenceRestoredApprovalExecution(invocation.prepared, params.executionFreshness),
+                })),
                 executionIds: group.entries.map((entry) => entry.executionId),
                 batch: group.batch,
                 diagnostic,

package/dist/src/runtime/orchestration/worker-capabilities/execution/execution-freshness.d.ts

@@ -0,0 +1,5 @@
+import type { WorkerCapabilityExecutionFreshness, WorkerCapabilityPreparedExecution } from "../contracts.js";
+export declare const STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION: "steering_superseded_before_external_execution";
+export declare const STEERING_SUPERSEDED_SUMMARY = "steering_superseded_before_external_execution: No external execution occurred because a newer active-request update superseded this capability invocation.";
+/** Preserve the admitted identity and decision binding; only fence its dispatch. */
+export declare function fenceRestoredApprovalExecution(prepared: WorkerCapabilityPreparedExecution, freshness: WorkerCapabilityExecutionFreshness | undefined): WorkerCapabilityPreparedExecution;

package/dist/src/runtime/orchestration/worker-capabilities/execution/execution-freshness.js

@@ -0,0 +1,31 @@
+export const STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION = "steering_superseded_before_external_execution";
+export const STEERING_SUPERSEDED_SUMMARY = "steering_superseded_before_external_execution: No external execution occurred because a newer active-request update superseded this capability invocation.";
+/** Preserve the admitted identity and decision binding; only fence its dispatch. */
+export function fenceRestoredApprovalExecution(prepared, freshness) {
+    if (!freshness)
+        return prepared;
+    return Object.freeze({
+        ...prepared,
+        async execute(executionId) {
+            if (freshness.isCurrent())
+                return prepared.execute(executionId);
+            if (prepared.rejectBeforeExecution)
+                return prepared.rejectBeforeExecution(executionId, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY);
+            return Object.freeze({
+                outcome: "failed",
+                observedEffect: "none",
+                summary: STEERING_SUPERSEDED_SUMMARY,
+                // This is request control, not evidence of a repeatable tool failure.
+                failureOutcomeFingerprint: null,
+                exactResult: Object.freeze({
+                    kind: "runtime_capability_rejection_v1",
+                    authority: "runtime",
+                    status: "rejected",
+                    stage: "before_external_execution",
+                    code: STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION,
+                    message: STEERING_SUPERSEDED_SUMMARY,
+                }),
+            });
+        },
+    });
+}

package/dist/src/runtime/passive-learning/application-catalog.js

@@ -1,4 +1,5 @@
 import { isLearningApplicationExcluded, learningApplicationKey } from "./application-policy.js";
+import { isOwnObservationApplication } from "../../shared/passive-observation-self-exclusion.js";
 /** Derived metadata only; counts cover retained observations, never lifetime usage. */
 export function learningApplicationCatalog(queued, history, preferences) {
     const rows = new Map();
@@ -18,7 +19,8 @@ export function learningApplicationCatalog(queued, history, preferences) {
             row.lastObservedAt = observation.timestamp;
         rows.set(key, row);
     }
-    const summaries = [...rows.values()].map((row) => ({ ...row,
+    const configurable = [...rows.values()].filter((row) => !isOwnObservationApplication(learningApplicationKey(row.app)));
+    const summaries = configurable.map((row) => ({ ...row,
         collectionExcluded: isLearningApplicationExcluded(row.app, preferences.excludedApplications),
         processingExcluded: isLearningApplicationExcluded(row.app, preferences.processingExcludedApplications),
     }));

package/dist/src/runtime/passive-learning/collection-source.js

@@ -12,6 +12,11 @@ function shouldReconnectCollectionSource(event) {
         return true;
     return event.reason === "collector_start_failed";
 }
+function requiresCollectionConsent(error) {
+    if (!(error instanceof Error))
+        return false;
+    return error.message === "collection_consent_required";
+}
 function hasHealthyCollectionEvent(event) {
     if (event.type === "observation")
         return true;
@@ -66,6 +71,8 @@ export class LearningCollectionSource {
             if (abort.signal.aborted)
                 return;
             this.options.failed(error);
+            if (requiresCollectionConsent(error))
+                return;
             this.reconnect();
         }
     }

package/dist/src/runtime/passive-learning/service.js

@@ -16,7 +16,7 @@ import { LearningJournal } from "./journal.js";
 import { ObservationQueue } from "./queue.js";
 import { canProcessLearningObservation, isLearningApplicationExcluded } from "./application-policy.js";
 import { commitLearningApplicationPreferences } from "./application-controls.js";
-import { learningFailureReason, summarizeBatch, } from "./status-projection.js";
+import { learningFailureReason, learningCollectionFailureState, summarizeBatch, } from "./status-projection.js";
 import { DEFAULT_LEARNING_PREFERENCES, normalizeLearningPreferences, } from "./store.js";
 export function createPassiveLearningService(options) {
     const service = new LearningService(options);
@@ -447,8 +447,7 @@ class LearningService {
     }
     failFeature(error) {
         this.reason = learningFailureReason(error);
-        this.state =
-            this.reason === "learning_host_unavailable" ? "unavailable" : "failed";
+        this.state = learningCollectionFailureState(this.reason);
         this.changed();
     }
     failProcessing(error) {

package/dist/src/runtime/passive-learning/status-projection.d.ts

@@ -1,3 +1,4 @@
+import type { PassiveCollectionState } from "../../shared/passive-observation.js";
 import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
 import type { LearningBatch, LearningBatchSummary } from "./contracts.js";
 export declare function summarizeBatch({ observations, reviewProgress: _reviewProgress, ...summary }: LearningBatch): LearningBatchSummary;
@@ -7,4 +8,5 @@ export declare function recentLearningMemories(memory: LongTermMemoryService, hi
     content: string;
     createdAt: string;
 }>[]>;
+export declare function learningCollectionFailureState(reason: string): PassiveCollectionState;
 export declare function learningFailureReason(error: unknown): string;

package/dist/src/runtime/passive-learning/status-projection.js

@@ -36,6 +36,13 @@ export async function recentLearningMemories(memory, history) {
         return [];
     }
 }
+export function learningCollectionFailureState(reason) {
+    if (reason === "collection_consent_required")
+        return "permission_required";
+    if (reason === "learning_host_unavailable")
+        return "unavailable";
+    return "failed";
+}
 export function learningFailureReason(error) {
     if (!(error instanceof Error))
         return "learning_failed";
@@ -48,6 +55,8 @@ export function learningFailureReason(error) {
         "learning_model_profile_overridden",
         "learning_memory_unavailable",
         "learning_host_unavailable",
+        "collection_consent_required",
+        "native_observation_identity_invalid",
         "learning_storage_unavailable",
         "learning_batch_timeout",
         "learning_disabled",

package/dist/src/runtime/plugins/installation/package.d.ts

@@ -10,6 +10,7 @@ export declare function preparePluginPackage(rootDir: string, source: PluginInst
         description?: string;
         extensions: Readonly<{
             [ABOT_RUNTIME_EXTENSION]: import("../../../plugin-contract/manifest.js").AbotRuntimePluginExtension;
+            ["ai.abot.compatibility"]?: import("../../../plugin-contract/platform-compatibility.js").PluginPlatformDeclaration;
             [namespace: string]: unknown;
         }>;
     }>;
@@ -23,6 +24,13 @@ export declare function preparePluginPackage(rootDir: string, source: PluginInst
         };
         digest: string;
         id: string;
+        compatibility: Readonly<{
+            supported: boolean;
+            status: "declared" | "legacy" | "unsupported" | "undeclared";
+            runtimePlatform: NodeJS.Platform;
+            runtimePlatforms?: readonly import("../../../plugin-contract/platform-compatibility.js").PluginRuntimePlatform[];
+            reason?: string;
+        }>;
         version: string;
         description: string;
         capabilities: {

package/dist/src/runtime/plugins/installation/package.js

@@ -2,6 +2,7 @@ import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { PluginInstallError, } from "../../../plugin-contract/install-source.js";
 import { ABOT_RUNTIME_EXTENSION } from "../../../plugin-contract/manifest.js";
+import { resolvePluginPlatformCompatibility } from "../platform-compatibility.js";
 import { parseAgentPluginManifest } from "../manifest-validator.js";
 import { projectManifestRuntimeContract } from "../manifest-projection.js";
 import { discoverConfiguredRuntimePluginManifests } from "../configured-manifests.js";
@@ -42,6 +43,7 @@ export async function preparePluginPackage(rootDir, source, download = downloadG
                 source: downloaded.source,
                 digest,
                 id: manifest.name,
+                compatibility: resolvePluginPlatformCompatibility(manifest),
                 version: manifest.version ?? "",
                 description: manifest.description ?? "",
                 capabilities: capabilities.map((id) => ({

package/dist/src/runtime/plugins/installation/service.d.ts

@@ -10,6 +10,13 @@ export declare function inspectPluginPackage(rootDir: string, input: unknown, do
     };
     digest: string;
     id: string;
+    compatibility: Readonly<{
+        supported: boolean;
+        status: "declared" | "legacy" | "unsupported" | "undeclared";
+        runtimePlatform: NodeJS.Platform;
+        runtimePlatforms?: readonly import("../../../plugin-contract/platform-compatibility.js").PluginRuntimePlatform[];
+        reason?: string;
+    }>;
     version: string;
     description: string;
     capabilities: {

package/dist/src/runtime/plugins/loader.js

@@ -11,6 +11,7 @@ import { discoverAgentPluginManifests } from "./manifest-discovery.js";
 import { resolveBundledRuntimeRoot } from "./bundled-root.js";
 import { projectManifestRuntimeContract } from "./manifest-projection.js";
 import { discoverConfiguredRuntimePluginManifests } from "./configured-manifests.js";
+import { resolvePluginPlatformCompatibility } from "./platform-compatibility.js";
 import { isPluginCatalogDisabled, isPluginToolSelected, normalizePluginSelection, pluginSelectionCacheKey, } from "./selection.js";
 const require = createRequire(import.meta.url);
 const compiledCatalogCache = new WeakMap();
@@ -110,20 +111,15 @@ export function loadConfiguredRuntimePlugins(config) {
     if (cached) {
         return cached;
     }
-    const host = {
-        rootDir: config.paths.rootDir,
-        pluginConfiguration: readPluginConfigurationStore(config.paths.rootDir)
-            .plugins,
-        runtimeId: config.runtimeId,
-        agentBridgeUrl: config.agentBridgeUrl,
-        runtimePaths: config.paths,
-    };
-    const manifestPlugins = discoverConfiguredRuntimePluginManifests(config.paths.rootDir, {
+    const discoveredPlugins = discoverConfiguredRuntimePluginManifests(config.paths.rootDir, {
         excludedPluginIds: new Set([
             ...selection.deny,
             ...selection.disabledPluginIds,
         ]),
-    })
+    });
+    const compatiblePlugins = discoveredPlugins.filter((plugin) => resolvePluginPlatformCompatibility(plugin.manifest).supported);
+    const allPluginsIncompatible = discoveredPlugins.length > 0 && compatiblePlugins.length === 0;
+    const selectedPlugins = compatiblePlugins
         .map((plugin) => ({
         plugin,
         selectedCapabilityIds: Object.keys(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities).filter((capabilityId) => isPluginToolSelected({
@@ -132,8 +128,17 @@ export function loadConfiguredRuntimePlugins(config) {
             selection,
         })),
     }))
-        .filter(({ selectedCapabilityIds }) => selectedCapabilityIds.length > 0)
-        .map(({ plugin, selectedCapabilityIds }) => loadManifestRuntimePlugin(host, plugin, selectedCapabilityIds));
+        .filter(({ selectedCapabilityIds }) => selectedCapabilityIds.length > 0);
+    const host = {
+        rootDir: config.paths.rootDir,
+        pluginConfiguration: allPluginsIncompatible
+            ? {}
+            : readPluginConfigurationStore(config.paths.rootDir).plugins,
+        runtimeId: config.runtimeId,
+        agentBridgeUrl: config.agentBridgeUrl,
+        runtimePaths: config.paths,
+    };
+    const manifestPlugins = selectedPlugins.map(({ plugin, selectedCapabilityIds }) => loadManifestRuntimePlugin(host, plugin, selectedCapabilityIds));
     const pluginIds = new Set();
     for (const plugin of manifestPlugins) {
         if (pluginIds.has(plugin.id)) {
@@ -175,14 +180,19 @@ export function loadBundledRuntimePlugins() {
     if (cached) {
         return cached;
     }
+    const discoveredPlugins = discoverAgentPluginManifests(packageRoot);
+    const selectedPlugins = discoveredPlugins.filter((plugin) => resolvePluginPlatformCompatibility(plugin.manifest).supported);
+    const allPluginsIncompatible = discoveredPlugins.length > 0 && selectedPlugins.length === 0;
     const host = {
         rootDir,
-        pluginConfiguration: readPluginConfigurationStore(rootDir).plugins,
+        pluginConfiguration: allPluginsIncompatible
+            ? {}
+            : readPluginConfigurationStore(rootDir).plugins,
         runtimeId: "default",
         agentBridgeUrl: "",
         runtimePaths: createUnconfiguredRuntimePaths(rootDir),
     };
-    const catalog = Object.freeze(discoverAgentPluginManifests(packageRoot).map((plugin) => freezeRuntimePlugin(loadManifestRuntimePlugin(host, plugin, Object.keys(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities)))));
+    const catalog = Object.freeze(selectedPlugins.map((plugin) => freezeRuntimePlugin(loadManifestRuntimePlugin(host, plugin, Object.keys(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities)))));
     bundledCatalogCache.set(cacheKey, catalog);
     return catalog;
 }

package/dist/src/runtime/plugins/manifest-platform-compatibility.d.ts

@@ -0,0 +1,2 @@
+import { type PluginPlatformDeclaration } from "../../plugin-contract/platform-compatibility.js";
+export declare function parsePluginPlatformDeclaration(value: unknown): PluginPlatformDeclaration | undefined;