pulseed 0.6.5 → 0.6.6

package/dist/runtime/capability-execution-resolver.js

@@ -0,0 +1,92 @@
+import { MCPServersConfigSchema } from "../base/types/mcp.js";
+import { buildCompanionCapabilityGraph } from "../platform/observation/capability-graph.js";
+import { loadRegistry } from "../platform/observation/capability-registry.js";
+import { AssetRegistry } from "./assets/registry.js";
+import { listBuiltinIntegrations } from "./builtin-integrations.js";
+export function createCapabilityExecutionResolver(input) {
+    return async (resolutionInput) => {
+        const graph = await loadCapabilityGraphForExecutionResolution(input.stateManager, input.generatedAt?.() ?? new Date().toISOString());
+        return resolveCapabilityExecutionFromGraph(graph, resolutionInput);
+    };
+}
+export function resolveCapabilityExecutionFromGraph(graph, input) {
+    const matches = [];
+    for (const candidate of graph.candidates) {
+        for (const provider of candidate.providers) {
+            for (const operation of candidate.operations) {
+                const toolName = toolNameForOperation(candidate, provider, operation);
+                if (toolName !== input.toolName)
+                    continue;
+                matches.push({
+                    score: operationMatchScore(operation, input),
+                    candidate,
+                    provider,
+                    operation,
+                    toolName,
+                });
+            }
+        }
+    }
+    const match = matches.sort((a, b) => b.score - a.score
+        || `${a.candidate.id}\0${a.provider.provider_id}\0${a.operation.id}`.localeCompare(`${b.candidate.id}\0${b.provider.provider_id}\0${b.operation.id}`))[0];
+    if (!match)
+        return null;
+    const assetRef = match.provider.asset_id ?? match.provider.provider_id;
+    return {
+        operationId: match.operation.id,
+        providerRef: match.provider.provider_id,
+        assetRef,
+        capabilityId: match.candidate.id,
+        operationKind: match.operation.operation_kind,
+        toolName: match.toolName,
+        payloadClass: match.operation.payload_class,
+        riskClass: match.operation.risk_profile,
+        sideEffectProfile: match.operation.side_effect_profile,
+        readinessSnapshotRefs: [readinessSnapshotId(match.candidate.id, match.provider.provider_id, match.operation.id)],
+    };
+}
+async function loadCapabilityGraphForExecutionResolution(stateManager, generatedAt) {
+    const [assets, legacyCapabilities, mcpServers] = await Promise.all([
+        new AssetRegistry({ baseDir: stateManager.getBaseDir() }).list().catch(() => []),
+        loadRegistry({ stateManager }).then((registry) => registry.capabilities).catch(() => []),
+        loadMcpServers(stateManager),
+    ]);
+    return buildCompanionCapabilityGraph({
+        assets,
+        legacyCapabilities,
+        mcpServers,
+        builtinIntegrations: listBuiltinIntegrations(),
+        generatedAt,
+    });
+}
+async function loadMcpServers(stateManager) {
+    for (const fileName of ["mcp-servers.json", "mcpServers.json"]) {
+        const raw = await stateManager.readRaw(fileName);
+        if (raw === null)
+            continue;
+        const parsed = MCPServersConfigSchema.safeParse(raw);
+        return parsed.success ? parsed.data.servers : [];
+    }
+    return [];
+}
+function operationMatchScore(operation, input) {
+    let score = 0;
+    if (operation.operation_kind === input.operationKind)
+        score += 4;
+    if (operation.payload_class === input.payloadClass)
+        score += 3;
+    if (operation.risk_profile === input.riskClass)
+        score += 2;
+    if (operation.side_effect_profile === input.sideEffectProfile)
+        score += 2;
+    return score;
+}
+function toolNameForOperation(candidate, provider, operation) {
+    if (provider.provider_kind === "mcp_server")
+        return candidate.name;
+    return operation.id;
+}
+function readinessSnapshotId(capabilityId, providerRef, operationId) {
+    return `readiness:${capabilityId}:${providerRef}:${operationId}`;
+}
+//# sourceMappingURL=capability-execution-resolver.js.map

package/dist/runtime/capability-execution-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-execution-resolver.js","sourceRoot":"","sources":["../../src/runtime/capability-execution-resolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAwB,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAE,6BAA6B,EAAE,MAAM,6CAA6C,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAC;AAO9E,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAOpE,MAAM,UAAU,iCAAiC,CAAC,KAGjD;IACC,OAAO,KAAK,EAAE,eAAe,EAAE,EAAE;QAC/B,MAAM,KAAK,GAAG,MAAM,yCAAyC,CAC3D,KAAK,CAAC,YAAY,EAClB,KAAK,CAAC,WAAW,EAAE,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAClD,CAAC;QACF,OAAO,mCAAmC,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;IACrE,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,mCAAmC,CACjD,KAAsB,EACtB,KAAyC;IAEzC,MAAM,OAAO,GAMR,EAAE,CAAC;IAER,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;QACzC,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;YAC3C,KAAK,MAAM,SAAS,IAAI,SAAS,CAAC,UAAU,EAAE,CAAC;gBAC7C,MAAM,QAAQ,GAAG,oBAAoB,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;gBACtE,IAAI,QAAQ,KAAK,KAAK,CAAC,QAAQ;oBAAE,SAAS;gBAC1C,OAAO,CAAC,IAAI,CAAC;oBACX,KAAK,EAAE,mBAAmB,CAAC,SAAS,EAAE,KAAK,CAAC;oBAC5C,SAAS;oBACT,QAAQ;oBACR,SAAS;oBACT,QAAQ;iBACT,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAClC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK;WACd,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,aAAa,CAChF,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,CAClE,CACF,CAAC,CAAC,CAAC,CAAC;IACL,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IAExB,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,QAAQ,IAAI,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC;IACvE,OAAO;QACL,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,EAAE;QAC/B,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,WAAW;QACvC,QAAQ;QACR,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,EAAE;QAChC,aAAa,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc;QAC7C,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,aAAa;QAC3C,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,YAAY;QACvC,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,mBAAmB;QACtD,qBAAqB,EAAE,CAAC,mBAAmB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;KACjH,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,yCAAyC,CACtD,YAA0B,EAC1B,WAAmB;IAEnB,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,UAAU,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QACjE,IAAI,aAAa,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC;QAChF,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC;QACxF,cAAc,CAAC,YAAY,CAAC;KAC7B,CAAC,CAAC;IACH,OAAO,6BAA6B,CAAC;QACnC,MAAM;QACN,kBAAkB;QAClB,UAAU;QACV,mBAAmB,EAAE,uBAAuB,EAAE;QAC9C,WAAW;KACZ,CAAC,CAAC;AACL,CAAC;AAED,KAAK,UAAU,cAAc,CAAC,YAA0B;IACtD,KAAK,MAAM,QAAQ,IAAI,CAAC,kBAAkB,EAAE,iBAAiB,CAAC,EAAE,CAAC;QAC/D,MAAM,GAAG,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACjD,IAAI,GAAG,KAAK,IAAI;YAAE,SAAS;QAC3B,MAAM,MAAM,GAAG,sBAAsB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACrD,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;IACnD,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,SAAS,mBAAmB,CAC1B,SAAsC,EACtC,KAAyC;IAEzC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,SAAS,CAAC,cAAc,KAAK,KAAK,CAAC,aAAa;QAAE,KAAK,IAAI,CAAC,CAAC;IACjE,IAAI,SAAS,CAAC,aAAa,KAAK,KAAK,CAAC,YAAY;QAAE,KAAK,IAAI,CAAC,CAAC;IAC/D,IAAI,SAAS,CAAC,YAAY,KAAK,KAAK,CAAC,SAAS;QAAE,KAAK,IAAI,CAAC,CAAC;IAC3D,IAAI,SAAS,CAAC,mBAAmB,KAAK,KAAK,CAAC,iBAAiB;QAAE,KAAK,IAAI,CAAC,CAAC;IAC1E,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,oBAAoB,CAC3B,SAA8B,EAC9B,QAA+B,EAC/B,SAAsC;IAEtC,IAAI,QAAQ,CAAC,aAAa,KAAK,YAAY;QAAE,OAAO,SAAS,CAAC,IAAI,CAAC;IACnE,OAAO,SAAS,CAAC,EAAE,CAAC;AACtB,CAAC;AAED,SAAS,mBAAmB,CAAC,YAAoB,EAAE,WAAmB,EAAE,WAAmB;IACzF,OAAO,aAAa,YAAY,IAAI,WAAW,IAAI,WAAW,EAAE,CAAC;AACnE,CAAC"}

package/dist/runtime/capability-operation-planner.d.ts

@@ -0,0 +1,81 @@
+import type { ScheduleEntry, ScheduleInternalAttentionProjection } from "./types/schedule.js";
+import type { CapabilityReadinessSnapshot } from "../platform/observation/types/capability.js";
+import { type AdmissionAuthState, type AdmissionPermissionGrantEvidenceInput, type AdmissionPolicyEvaluation, type AdmissionPolicySignal, type AdmissionSurfaceScopeInput } from "./control/admission-policy.js";
+import { type AutonomyCacheInvalidationEvidence, type AutonomyCompanionState, type AutonomyContextAuthorityEvidence, type AutonomyDecision, type AutonomyFeedbackSignal, type AutonomyPolicySignal, type AutonomyRuntimeControlState, type AutonomyTrustProfile, type AutonomyVerificationProfile } from "./control/autonomy-governor.js";
+import { type CapabilityOperationPlanAssembly } from "./types/capability-operation-plan.js";
+import type { RuntimeControlActor } from "./store/runtime-operation-schemas.js";
+export type ResidentOperationPlanAction = "sleep" | "suggest_goal" | "investigate" | "preemptive_check" | "curiosity" | "curiosity_noop";
+export interface ResidentAttentionOperationProjection {
+    action: ResidentOperationPlanAction;
+    source_kind: "resident_proactive_maintenance" | "resident_curiosity";
+    attention_input_id: string;
+    signal_context_id: string;
+    urge_id: string;
+    agenda_item_id: string;
+    inhibition_decision_id: string;
+    initiative_gate_decision_id: string;
+    outcome_decision_id?: string;
+    requested_outcome: string;
+    admission_status: string;
+    final_outcome?: string;
+    branch_admitted: boolean;
+}
+export interface ResidentOperationPlanAssemblyInput {
+    admission: ResidentAttentionOperationProjection;
+    assembledAt: string;
+    goalId?: string | null;
+    details?: Record<string, unknown>;
+    surfaceRef?: string | null;
+}
+export interface ResidentOperationBoundaryInput extends ResidentOperationPlanAssemblyInput {
+    actor?: RuntimeControlActor;
+    surface?: AdmissionSurfaceScopeInput;
+    readinessSnapshots?: CapabilityReadinessSnapshot[];
+    permissionGrants?: AdmissionPermissionGrantEvidenceInput[];
+    relationshipPolicy?: AdmissionPolicySignal[];
+    quietingPolicy?: AdmissionPolicySignal[];
+    privacyPolicy?: AdmissionPolicySignal[];
+    runtimeControlPolicy?: AdmissionPolicySignal[];
+    notificationPolicy?: AdmissionPolicySignal[];
+    authState?: AdmissionAuthState;
+    runtimeControlState?: AutonomyRuntimeControlState;
+    companionState?: AutonomyCompanionState;
+    trustProfile?: AutonomyTrustProfile;
+    verificationProfile?: AutonomyVerificationProfile;
+    recentFeedback?: AutonomyFeedbackSignal[];
+    contextAuthorityEvidence?: AutonomyContextAuthorityEvidence[];
+    invalidationEvidence?: AutonomyCacheInvalidationEvidence[];
+    autonomyRelationshipPolicy?: AutonomyPolicySignal[];
+    autonomyQuietingPolicy?: AutonomyPolicySignal[];
+    autonomyPrivacyContext?: AutonomyPolicySignal[];
+    autonomyGuardrailState?: AutonomyPolicySignal[];
+    autonomyBackpressureState?: AutonomyPolicySignal[];
+}
+export interface ResidentOperationBoundaryResult {
+    assembly: CapabilityOperationPlanAssembly;
+    admission_evaluation?: AdmissionPolicyEvaluation;
+    autonomy_decision?: AutonomyDecision;
+    preparation_allowed: boolean;
+    execution_allowed: boolean;
+}
+export interface ScheduleOperationPlanAssemblyInput {
+    entry: ScheduleEntry;
+    firedAt: string;
+    scheduledFor?: string | null;
+    projection?: ScheduleInternalAttentionProjection;
+}
+export declare function assembleScheduleOperationPlans(input: ScheduleOperationPlanAssemblyInput): CapabilityOperationPlanAssembly;
+export declare function assembleResidentOperationPlans(input: ResidentOperationPlanAssemblyInput): CapabilityOperationPlanAssembly;
+export declare function evaluateResidentOperationBoundary(input: ResidentOperationBoundaryInput): ResidentOperationBoundaryResult;
+export declare function residentOperationBoundaryActivityMetadata(boundary: ResidentOperationBoundaryResult): {
+    operation_plan_assembly_id: string;
+    operation_plan_status: CapabilityOperationPlanAssembly["status"];
+    operation_plan_reason: string;
+    operation_plan_id?: string;
+    operation_admission_evaluation_id?: string;
+    autonomy_decision_id?: string;
+    autonomy_decision_level?: AutonomyDecision["level"];
+    operation_preparation_allowed: boolean;
+    operation_execution_allowed: boolean;
+};
+//# sourceMappingURL=capability-operation-planner.d.ts.map

package/dist/runtime/capability-operation-planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-operation-planner.d.ts","sourceRoot":"","sources":["../../src/runtime/capability-operation-planner.ts"],"names":[],"mappings":"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"}

package/dist/runtime/capability-operation-planner.js

@@ -0,0 +1,481 @@
+import { evaluateAdmissionPolicy, } from "./control/admission-policy.js";
+import { evaluateAutonomyDecision, } from "./control/autonomy-governor.js";
+import { CapabilityOperationPlanAssemblySchema, } from "./types/capability-operation-plan.js";
+const WAIT_RESUME_CAPABILITY_ID = "capability:schedule_wait_resume_attention";
+const WAIT_RESUME_PAYLOAD_CLASS = "schedule_wait_resume_attention_projection";
+const RESIDENT_DAEMON_SURFACE_REF = "surface:resident-daemon";
+export function assembleScheduleOperationPlans(input) {
+    const sourceRef = `schedule:${input.entry.id}`;
+    const source = {
+        kind: "schedule_tick",
+        source_ref: sourceRef,
+        source_epoch: input.entry.updated_at,
+        emitted_at: input.firedAt,
+        metadata: {
+            entry_id: input.entry.id,
+            layer: input.entry.layer,
+            activation_kind: input.entry.metadata?.activation_kind ?? null,
+        },
+    };
+    if (input.entry.metadata?.activation_kind !== "wait_resume") {
+        return CapabilityOperationPlanAssemblySchema.parse({
+            schema_version: "capability-operation-plan-assembly/v1",
+            assembly_id: `operation-plan-assembly:schedule:${input.entry.id}:${input.firedAt}`,
+            assembled_at: input.firedAt,
+            source,
+            status: "no_supported_plan",
+            reason: "Schedule entry is not a supported non-chat operation proposal source.",
+            candidate_plans: [],
+        });
+    }
+    const triggerGoalId = input.entry.goal_trigger?.goal_id;
+    const metadataGoalId = input.entry.metadata.goal_id;
+    if (!input.entry.goal_trigger || !triggerGoalId || !metadataGoalId || metadataGoalId !== triggerGoalId) {
+        return failClosed(input, source, "Wait-resume schedule entry is missing a stable goal trigger context.");
+    }
+    if (!input.projection) {
+        return failClosed(input, source, "Wait-resume schedule entry did not produce a structured attention projection.");
+    }
+    const expectedSignalContextId = `signal:schedule-wake:${input.entry.id}:${input.scheduledFor ?? input.firedAt}`;
+    if (input.projection.signal_context_id !== expectedSignalContextId) {
+        return failClosed(input, source, "Wait-resume attention projection does not match the schedule tick context.");
+    }
+    const operationId = `schedule.wait_resume.attention.${input.entry.id}`;
+    const providerRef = sourceRef;
+    const targetRefs = [
+        `goal:${triggerGoalId}`,
+        input.projection.signal_context_id,
+        ...input.projection.urge_candidate_refs,
+        ...input.projection.agenda_item_refs,
+        ...input.projection.runtime_items.map((item) => item.ref),
+    ];
+    const candidate = {
+        plan_id: `operation-plan:${operationId}:${input.firedAt}`,
+        source_ref: sourceRef,
+        operation_plan: {
+            operation_id: operationId,
+            capability_id: WAIT_RESUME_CAPABILITY_ID,
+            operation_kind: "hint",
+            provider_ref: providerRef,
+            payload_class: WAIT_RESUME_PAYLOAD_CLASS,
+            side_effect_profile: "none",
+            risk_class: "low",
+            privacy_profile: "workspace_private",
+            reversibility: "reversible",
+            external_action_authority: false,
+            target_refs: targetRefs,
+            advisory_only: true,
+            preparable_when_blocked: true,
+            local_only: true,
+            inspectable: true,
+            expected_user_visible_effect: false,
+        },
+        admission_scope: {
+            operation_id: operationId,
+            capability_id: WAIT_RESUME_CAPABILITY_ID,
+            operation_kind: "hint",
+            provider_ref: providerRef,
+            asset_ref: providerRef,
+            payload_class: WAIT_RESUME_PAYLOAD_CLASS,
+            payload_epoch: input.projection.projected_at,
+            side_effect_profile: "none",
+            external_action_authority: false,
+            requires_runtime_control: false,
+            required_permission_capabilities: [],
+            target_refs: targetRefs,
+            target_epoch_refs: {
+                [providerRef]: input.entry.updated_at,
+                [input.projection.signal_context_id]: input.projection.projected_at,
+            },
+            provider_epoch: input.entry.updated_at,
+        },
+        readiness_snapshot_refs: [],
+        required_approvals: [],
+        reversible_preparation_steps: [
+            "Record the attention projection as inspectable planning context.",
+        ],
+        not_allowed_steps: [
+            "Do not run the goal from this planner output.",
+            "Do not send external notifications from this planner output.",
+            "Do not treat the attention projection as runtime-control admission.",
+        ],
+        user_visible_summary: "Wait-resume attention projection is available as a candidate planning hint; downstream gates decide any action.",
+        audit_seed: {
+            schedule_entry_id: input.entry.id,
+            goal_id: triggerGoalId,
+            signal_context_id: input.projection.signal_context_id,
+            urge_candidate_refs: input.projection.urge_candidate_refs,
+            agenda_item_refs: input.projection.agenda_item_refs,
+            runtime_item_refs: input.projection.runtime_items.map((item) => item.ref),
+        },
+    };
+    return CapabilityOperationPlanAssemblySchema.parse({
+        schema_version: "capability-operation-plan-assembly/v1",
+        assembly_id: `operation-plan-assembly:schedule:${input.entry.id}:${input.firedAt}`,
+        assembled_at: input.firedAt,
+        source,
+        status: "planned",
+        reason: "Wait-resume schedule attention projection assembled into an advisory candidate operation plan.",
+        candidate_plans: [candidate],
+    });
+}
+export function assembleResidentOperationPlans(input) {
+    const sourceRef = input.admission.outcome_decision_id
+        ?? input.admission.agenda_item_id
+        ?? input.admission.attention_input_id;
+    const source = residentOperationPlanSource(input, sourceRef);
+    const config = residentPlanConfig(input.admission.action, input.goalId ?? "");
+    if (!config) {
+        return CapabilityOperationPlanAssemblySchema.parse({
+            schema_version: "capability-operation-plan-assembly/v1",
+            assembly_id: residentOperationPlanAssemblyId(input, sourceRef),
+            assembled_at: input.assembledAt,
+            source,
+            status: "no_supported_plan",
+            reason: "Resident attention outcome does not require a capability operation plan.",
+            candidate_plans: [],
+        });
+    }
+    const failedReason = residentOperationPlanFailClosedReason(input, config);
+    if (failedReason) {
+        return CapabilityOperationPlanAssemblySchema.parse({
+            schema_version: "capability-operation-plan-assembly/v1",
+            assembly_id: residentOperationPlanAssemblyId(input, sourceRef),
+            assembled_at: input.assembledAt,
+            source,
+            status: "fail_closed",
+            reason: failedReason,
+            candidate_plans: [],
+        });
+    }
+    const operationId = `${config.operationIdPrefix}.${residentOperationPlanToken(sourceRef)}`;
+    const targetRefs = residentOperationPlanTargetRefs(input);
+    const providerRef = config.providerRef;
+    const candidate = {
+        plan_id: `operation-plan:${operationId}`,
+        source_ref: sourceRef,
+        operation_plan: {
+            operation_id: operationId,
+            capability_id: config.capabilityId,
+            operation_kind: config.operationKind,
+            provider_ref: providerRef,
+            payload_class: config.payloadClass,
+            side_effect_profile: config.sideEffectProfile,
+            risk_class: config.riskClass,
+            privacy_profile: config.privacyProfile,
+            reversibility: config.reversibility,
+            external_action_authority: false,
+            target_refs: targetRefs,
+            advisory_only: config.advisoryOnly,
+            preparable_when_blocked: config.preparableWhenBlocked,
+            local_only: true,
+            inspectable: true,
+            expected_user_visible_effect: false,
+        },
+        admission_scope: {
+            operation_id: operationId,
+            capability_id: config.capabilityId,
+            operation_kind: config.operationKind,
+            provider_ref: providerRef,
+            asset_ref: providerRef,
+            payload_class: config.payloadClass,
+            payload_epoch: input.admission.outcome_decision_id ?? input.admission.agenda_item_id,
+            side_effect_profile: config.sideEffectProfile,
+            external_action_authority: false,
+            requires_runtime_control: config.requiresRuntimeControl,
+            required_permission_capabilities: config.requiredPermissionCapabilities,
+            target_refs: targetRefs,
+            target_epoch_refs: {
+                [input.admission.attention_input_id]: input.admission.attention_input_id,
+                [input.admission.agenda_item_id]: input.admission.agenda_item_id,
+                ...(input.admission.outcome_decision_id
+                    ? { [input.admission.outcome_decision_id]: input.admission.outcome_decision_id }
+                    : {}),
+            },
+            provider_epoch: input.admission.source_kind,
+        },
+        readiness_snapshot_refs: [],
+        required_approvals: config.requiredApprovals,
+        reversible_preparation_steps: residentPreparationSteps(input.admission.action),
+        not_allowed_steps: [
+            "Do not start, resume, or finalize runtime work from this resident operation plan.",
+            "Do not notify or speak from this resident operation plan.",
+            "Do not infer initiation authority from Dream hints, notification routes, authenticated sessions, MCP enablement, or past success.",
+            "Require a matching admission evaluation and autonomy decision before any executor or user-visible delivery path.",
+        ],
+        user_visible_summary: config.userVisibleSummary,
+        audit_seed: {
+            action: input.admission.action,
+            attention_input_id: input.admission.attention_input_id,
+            signal_context_id: input.admission.signal_context_id,
+            agenda_item_id: input.admission.agenda_item_id,
+            outcome_decision_id: input.admission.outcome_decision_id ?? null,
+            goal_id: input.goalId ?? null,
+            source_kind: input.admission.source_kind,
+        },
+    };
+    return CapabilityOperationPlanAssemblySchema.parse({
+        schema_version: "capability-operation-plan-assembly/v1",
+        assembly_id: residentOperationPlanAssemblyId(input, sourceRef),
+        assembled_at: input.assembledAt,
+        source,
+        status: "planned",
+        reason: "Resident attention proposal assembled into a bounded candidate operation plan.",
+        candidate_plans: [candidate],
+    });
+}
+export function evaluateResidentOperationBoundary(input) {
+    const assembly = assembleResidentOperationPlans(input);
+    const candidate = assembly.candidate_plans[0];
+    if (!candidate) {
+        return {
+            assembly,
+            preparation_allowed: false,
+            execution_allowed: false,
+        };
+    }
+    const actor = input.actor ?? {
+        surface: "cli",
+        identity_key: "resident-daemon",
+    };
+    const surface = input.surface ?? {
+        surface_ref: input.surfaceRef ?? RESIDENT_DAEMON_SURFACE_REF,
+        channel: "daemon",
+        platform: "resident",
+        epoch: input.admission.outcome_decision_id ?? input.admission.agenda_item_id,
+    };
+    const evaluatedAt = input.assembledAt;
+    const readinessSnapshots = input.readinessSnapshots ?? [];
+    const admission = evaluateAdmissionPolicy({
+        operation: candidate.admission_scope,
+        actor,
+        surface,
+        authState: input.authState,
+        readiness: readinessSnapshots.find((snapshot) => snapshot.operation_id === candidate.operation_plan.operation_id
+            && snapshot.capability_id === candidate.operation_plan.capability_id
+            && snapshot.provider_ref === candidate.operation_plan.provider_ref
+            && snapshot.payload_class === candidate.operation_plan.payload_class),
+        permissionGrants: input.permissionGrants ?? [],
+        relationshipPolicy: input.relationshipPolicy ?? [],
+        quietingPolicy: input.quietingPolicy ?? [],
+        privacyPolicy: input.privacyPolicy ?? [],
+        runtimeControlPolicy: input.runtimeControlPolicy ?? [],
+        notificationPolicy: input.notificationPolicy ?? [],
+        evaluatedAt,
+        evaluationId: `admission:${candidate.operation_plan.operation_id}:${residentOperationPlanToken(surface.surface_ref)}`,
+    });
+    const autonomyDecision = evaluateAutonomyDecision({
+        operation_plan: candidate.operation_plan,
+        readiness_snapshots: readinessSnapshots,
+        admission_evaluation: admission,
+        user_directed: false,
+        active_surface_ref: surface.surface_ref,
+        auth_state: input.authState,
+        relationship_permissions: input.autonomyRelationshipPolicy ?? [],
+        quieting_policy: input.autonomyQuietingPolicy ?? [],
+        privacy_context: input.autonomyPrivacyContext ?? [],
+        runtime_control_state: input.runtimeControlState,
+        companion_state: input.companionState,
+        guardrail_state: input.autonomyGuardrailState ?? [],
+        backpressure_state: input.autonomyBackpressureState ?? [],
+        trust_profile: input.trustProfile,
+        verification_profile: input.verificationProfile,
+        recent_feedback: input.recentFeedback ?? [],
+        context_authority_evidence: input.contextAuthorityEvidence ?? [],
+        invalidation_evidence: input.invalidationEvidence ?? [],
+        blast_radius: candidate.operation_plan.side_effect_profile === "read" ? "workspace" : "local",
+        privacy_sensitivity: candidate.operation_plan.privacy_profile === "local_private" ? "low" : "medium",
+        evaluated_at: evaluatedAt,
+        decision_id: `autonomy:${candidate.operation_plan.operation_id}:${residentOperationPlanToken(admission.evaluation_id)}`,
+    });
+    return {
+        assembly,
+        admission_evaluation: admission,
+        autonomy_decision: autonomyDecision,
+        preparation_allowed: autonomyDecision.allowed_steps.includes("prepare")
+            || autonomyDecision.allowed_steps.includes("advise"),
+        execution_allowed: autonomyDecision.allowed_steps.some((step) => step.includes("execute")),
+    };
+}
+export function residentOperationBoundaryActivityMetadata(boundary) {
+    const candidate = boundary.assembly.candidate_plans[0];
+    return {
+        operation_plan_assembly_id: boundary.assembly.assembly_id,
+        operation_plan_status: boundary.assembly.status,
+        operation_plan_reason: boundary.assembly.reason,
+        ...(candidate ? { operation_plan_id: candidate.plan_id } : {}),
+        ...(boundary.admission_evaluation
+            ? { operation_admission_evaluation_id: boundary.admission_evaluation.evaluation_id }
+            : {}),
+        ...(boundary.autonomy_decision
+            ? {
+                autonomy_decision_id: boundary.autonomy_decision.decision_id,
+                autonomy_decision_level: boundary.autonomy_decision.level,
+            }
+            : {}),
+        operation_preparation_allowed: boundary.preparation_allowed,
+        operation_execution_allowed: boundary.execution_allowed,
+    };
+}
+function failClosed(input, source, reason) {
+    return CapabilityOperationPlanAssemblySchema.parse({
+        schema_version: "capability-operation-plan-assembly/v1",
+        assembly_id: `operation-plan-assembly:schedule:${input.entry.id}:${input.firedAt}`,
+        assembled_at: input.firedAt,
+        source,
+        status: "fail_closed",
+        reason,
+        candidate_plans: [],
+    });
+}
+function residentOperationPlanSource(input, sourceRef) {
+    return {
+        kind: "attention_projection",
+        source_ref: sourceRef,
+        source_epoch: input.admission.outcome_decision_id ?? input.admission.agenda_item_id,
+        emitted_at: input.assembledAt,
+        metadata: {
+            action: input.admission.action,
+            source_kind: input.admission.source_kind,
+            attention_input_id: input.admission.attention_input_id,
+            signal_context_id: input.admission.signal_context_id,
+            agenda_item_id: input.admission.agenda_item_id,
+            outcome_decision_id: input.admission.outcome_decision_id ?? null,
+            goal_id: input.goalId ?? null,
+        },
+    };
+}
+function residentPlanConfig(action, goalId) {
+    switch (action) {
+        case "suggest_goal":
+            return {
+                capabilityId: "capability:resident_goal_suggestion_preparation",
+                operationIdPrefix: "resident.goal_suggestion.prepare",
+                operationKind: "prepare",
+                providerRef: "resident:goal-negotiator",
+                payloadClass: "resident.goal_suggestion",
+                sideEffectProfile: "write",
+                riskClass: "low",
+                privacyProfile: "workspace_private",
+                reversibility: "draft_only",
+                advisoryOnly: false,
+                preparableWhenBlocked: true,
+                requiresRuntimeControl: false,
+                requiredPermissionCapabilities: [],
+                requiredApprovals: [],
+                userVisibleSummary: "Resident goal suggestion may prepare a local draft only; downstream gates decide whether to ask or act.",
+            };
+        case "investigate":
+        case "curiosity":
+            return {
+                capabilityId: "capability:resident_curiosity_preparation",
+                operationIdPrefix: "resident.curiosity.prepare",
+                operationKind: "prepare",
+                providerRef: "resident:curiosity-engine",
+                payloadClass: "resident.curiosity_proposal",
+                sideEffectProfile: "write",
+                riskClass: "low",
+                privacyProfile: "workspace_private",
+                reversibility: "draft_only",
+                advisoryOnly: false,
+                preparableWhenBlocked: true,
+                requiresRuntimeControl: false,
+                requiredPermissionCapabilities: [],
+                requiredApprovals: [],
+                userVisibleSummary: "Resident curiosity may prepare an inspectable proposal only; it cannot start work or notify.",
+            };
+        case "preemptive_check":
+            return {
+                capabilityId: "capability:resident_preemptive_check_preparation",
+                operationIdPrefix: "resident.preemptive_check.prepare",
+                operationKind: "read",
+                providerRef: "resident:preemptive-check",
+                payloadClass: "resident.preemptive_check",
+                sideEffectProfile: "read",
+                riskClass: "medium",
+                privacyProfile: "workspace_private",
+                reversibility: "reversible",
+                advisoryOnly: false,
+                preparableWhenBlocked: true,
+                requiresRuntimeControl: true,
+                requiredPermissionCapabilities: ["read_workspace"],
+                requiredApprovals: [`runtime-control:resident-preemptive-check:${goalId || "unknown"}`],
+                userVisibleSummary: "Resident preemptive check is only a prepared read candidate until runtime-control admission is granted.",
+            };
+        case "sleep":
+        case "curiosity_noop":
+            return null;
+    }
+}
+function residentOperationPlanFailClosedReason(input, config) {
+    if (!input.admission.attention_input_id || !input.admission.agenda_item_id) {
+        return "Resident operation plan context is missing attention or agenda refs.";
+    }
+    if (!input.admission.outcome_decision_id) {
+        return "Resident operation plan context is missing an outcome decision ref.";
+    }
+    if (input.admission.action === "preemptive_check" && !(input.goalId ?? "").trim()) {
+        return "Resident preemptive operation plan requires a current goal target.";
+    }
+    const requested = input.admission.requested_outcome;
+    const finalOutcome = input.admission.final_outcome ?? requested;
+    if (input.admission.action === "preemptive_check") {
+        if (requested !== "prepare_action_candidate") {
+            return "Resident preemptive operation plan requires a prepare_action_candidate attention outcome.";
+        }
+        return null;
+    }
+    if (!input.admission.branch_admitted) {
+        return "Resident operation plan requires an admitted attention outcome before preparing a proposal.";
+    }
+    if (finalOutcome !== "prepare_silently") {
+        return `Resident operation plan cannot prepare from attention outcome ${finalOutcome}.`;
+    }
+    if (config.requiresRuntimeControl && input.admission.admission_status === "admitted") {
+        return "Resident runtime-control operation cannot bypass downstream runtime-control admission.";
+    }
+    return null;
+}
+function residentOperationPlanAssemblyId(input, sourceRef) {
+    return `operation-plan-assembly:resident:${input.admission.action}:${residentOperationPlanToken(sourceRef)}`;
+}
+function residentOperationPlanToken(value) {
+    return encodeURIComponent(value).replace(/%/g, "_");
+}
+function residentOperationPlanTargetRefs(input) {
+    return [
+        input.admission.attention_input_id,
+        input.admission.signal_context_id,
+        input.admission.urge_id,
+        input.admission.agenda_item_id,
+        input.admission.inhibition_decision_id,
+        input.admission.initiative_gate_decision_id,
+        ...(input.admission.outcome_decision_id ? [input.admission.outcome_decision_id] : []),
+        ...(input.goalId ? [`goal:${input.goalId}`] : []),
+        ...(input.surfaceRef ? [input.surfaceRef] : []),
+    ];
+}
+function residentPreparationSteps(action) {
+    switch (action) {
+        case "suggest_goal":
+            return [
+                "Prepare an inspectable local goal suggestion draft.",
+                "Leave runtime start, negotiation, notification, and user-visible delivery to later admitted surfaces.",
+            ];
+        case "investigate":
+        case "curiosity":
+            return [
+                "Prepare an inspectable curiosity proposal.",
+                "Keep the proposal local until shared delivery or runtime-control admission chooses a route.",
+            ];
+        case "preemptive_check":
+            return [
+                "Record the preemptive check as a read candidate.",
+                "Wait for runtime-control admission before any runtime executor or user-visible route.",
+            ];
+        case "sleep":
+        case "curiosity_noop":
+            return [];
+    }
+}
+//# sourceMappingURL=capability-operation-planner.js.map