qlogicagent 2.13.3 → 2.13.5

package/dist/cli/rpc-registry.js

@@ -0,0 +1,243 @@
+import { handleAgentsApprovalResponse, handleAgentsWarm, handleAgentsCatalog, handleAgentsConfig, handleAgentsGetConfig, handleAgentsGetGateway, handleAgentsGetLog, handleAgentsInstall, handleAgentsKill, handleAgentsList, handleAgentsListConfigured, handleAgentsProcesses, handleAgentsPrompt, handleAgentsRemoveConfig, handleAgentsScan, handleAgentsSetConfig, handleAgentsSetGateway, handleAgentsTestConnection } from "./handlers/agents-handler.js";
+import { handleCommunityGetConsent, handleCommunityInstallResource, handleCommunityInstallRuntime, handleCommunityListNotices, handleCommunityListPublishAudit, handleCommunityListShared, handleCommunityMarkNoticeRead, handleCommunityMatchRegistry, handleCommunityPublishPet, handleCommunityPublishSkill, handleCommunityRecordSignal, handleCommunityRecordTelemetry, handleCommunityResolveInstall, handleCommunityRuntimeStatus, handleCommunitySetConsent, handleCommunityWithdrawAllShared, handleCommunityWithdrawShared } from "./handlers/community-handler.js";
+import { handleConfigGet, handleConfigTunables, handleConfigUpdate, handleConfigUpdateTunable, handleProviderList, handleTasksCancel, handleTasksList, handleTodosList, handleToolsList } from "./handlers/config-handler.js";
+import { handleCancel, handleHealth, handleInitialize, handleMetrics, handlePing } from "./handlers/control-handler.js";
+import { handleFilesCreate, handleFilesDelete, handleFilesGitStatus, handleFilesList, handleFilesRead, handleFilesRename, handleInstructionsDelete, handleInstructionsList, handleInstructionsRead, handleInstructionsWrite, handlePlansList } from "./handlers/files-handler.js";
+import { handleMediaCancel, handleMediaListModels, handleMediaStatus, handleMediaStt } from "./handlers/media-handler.js";
+import { handleMemoryActivity, handleMemoryAtlas, handleMemoryAttachmentAdopt, handleMemoryAttachmentLocate, handleMemoryConsolidate, handleMemoryDelete, handleMemoryList, handleMemoryObserve, handleMemoryPropose, handleMemoryRead, handleMemorySearch, handleMemoryUpdate, handleMemoryWrite } from "./handlers/memory-handler.js";
+import { handlePetConfirmResponse } from "./handlers/pet-confirm-handler.js";
+import { handlePetAssetImport, handlePetCustomDelete, handlePetForge, handlePetInteract, handlePetJourneyGet, handlePetJourneyList, handlePetJourneySnapshot, handlePetPreferencesUpdate, handlePetStatus } from "./handlers/pet-handler.js";
+import { handleProductCancel, handleProductCheckpoint, handleProductConfirm, handleProductCreate, handleProductDelete, handleProductList, handleProductMessage, handleProductPause, handleProductPlan, handleProductResume, handleProductRollback, handleProductStatus } from "./handlers/product-handler.js";
+import { handleCredentialCreate, handleCredentialDelete, handleCredentialList, handleCredentialOauthComplete, handleCredentialOauthStart, handleWorkflowApprove, handleWorkflowApprovals, handleWorkflowAudit, handleWorkflowArchive, handleWorkflowCancelRun, handleWorkflowCapabilities, handleWorkflowCreate, handleWorkflowDelete, handleWorkflowDescribe, handleWorkflowDryRun, handleWorkflowDuplicate, handleWorkflowExport, handleWorkflowGet, handleWorkflowImport, handleWorkflowIntentIndex, handleWorkflowList, handleWorkflowMetrics, handleWorkflowOnForm, handleWorkflowOnImMessage, handleWorkflowOnIntent, handleWorkflowOnWebhook, handleWorkflowPatch, handleWorkflowPublish, handleWorkflowPublishHub, handleWorkflowRevert, handleWorkflowRevisions, handleWorkflowRun, handleWorkflowRunDetail, handleWorkflowRuns, handleWorkflowSetActive, handleWorkflowSetPermissionScope, handleWorkflowUpdate } from "./handlers/workflow-handler.js";
+import { handleProjectArchive, handleProjectArchiveByGroup, handleProjectCreate, handleProjectDelete, handleProjectList, handleProjectPurgeAll, handleProjectRename, handleProjectUnarchive, handleProjectUpdate } from "./handlers/project-handler.js";
+import { handleSessionArchive, handleSessionCreate, handleSessionDelete, handleSessionDeleteAll, handleSessionFocus, handleSessionGet, handleSessionGetInfo, handleSessionGetMessages, handleSessionGetState, handleSessionList, handleSessionMoveToProject, handleSessionResolve, handleSessionResume, handleSessionSwitchProject, handleSessionUpdate, handleThreadCreate, handleThreadList } from "./handlers/session-handler.js";
+import { handleSettingsAddKey, handleSettingsCopyKey, handleSettingsGetActiveModel, handleSettingsGetKey, handleSettingsGetOverview, handleSettingsListModels, handleSettingsListProviders, handleSettingsRefreshModels, handleSettingsRemoveKey, handleSettingsSetActiveModel, handleSettingsToggleKey, handleSettingsToggleModel, handleSettingsValidateKey } from "./handlers/settings-handler.js";
+import { handleSkillsActivate, handleSkillsCurator, handleSkillsDeactivate, handleSkillsDelete, handleSkillsLifecycle, handleSkillsList, handleSkillsPin, handleSkillsPromote, handleSkillsStats, handleSkillsUnpin } from "./handlers/skills-handler.js";
+import { handleSoloCancel, handleSoloDelete, handleSoloEvaluate, handleSoloList, handleSoloMessage, handleSoloSelect, handleSoloStart, handleSoloStatus } from "./handlers/solo-handler.js";
+import { handleUserResponse } from "./handlers/turn-handler.js";
+import { handleDream } from "./handlers/dream-handler.js";
+function configHost(hosts) { return hosts.config; }
+function controlHost(hosts) { return hosts.control; }
+function communityHost(hosts) { return hosts.community; }
+function dreamHost(hosts) { return hosts.dream; }
+function filesHost(hosts) { return hosts.files; }
+function mediaHost(hosts) { return hosts.media; }
+function memoryHost(hosts) { return hosts.memory; }
+function petHost(hosts) { return hosts.pet; }
+function petConfirmHost(hosts) { return hosts.petConfirm; }
+function projectHost(hosts) { return hosts.project; }
+function sessionHost(hosts) { return hosts.session; }
+function settingsHost(hosts) { return hosts.settings; }
+function skillsHost(hosts) { return hosts.skills; }
+function turnControlHost(hosts) { return hosts.turn; }
+// agents/solo/product run on the multi-agent sub-host, whose type
+// (Agents & Solo & Product) statically satisfies each — no cast needed.
+function multiAgentHost(hosts) { return hosts.multiAgent; }
+function agentsHost(hosts) { return hosts.multiAgent; }
+function productHost(hosts) { return hosts.multiAgent; }
+function soloHost(hosts) { return hosts.multiAgent; }
+// workflow.* binds to its own host (WorkflowHostAdapter), which carries `toolCatalog` plus the
+// lazy controller/store/scheduler/processManager slots ensureWorkflowController fills. The legacy
+// workflow.* RPC path IS live — the gateway drives workflow.list (arm-on-reconnect),
+// workflow.onImMessage (IM triggers), workflow.onWebhook (HTTP routes), and the automation UI sends
+// workflow.create/run/patch/… — so the binding must be real, not a cast over the toolCatalog-less
+// multi-agent sub-host (which made a workflow `tool` node throw on `this.toolCatalog.findTool`).
+function workflowHost(hosts) { return hosts.workflow; }
+export function createRpcMethodRegistry(host) {
+    return new Map([
+        ["initialize", (m) => handleInitialize.call(controlHost(host), m)],
+        ["agent.ping", (m) => handlePing.call(controlHost(host), m)],
+        ["agent.health", (m) => handleHealth.call(controlHost(host), m)],
+        ["agent.metrics", (m) => handleMetrics.call(controlHost(host), m)],
+        ["agent.cancel", (m) => handleCancel.call(controlHost(host), m)], ["memory.dream", (m) => handleDream.call(dreamHost(host), m)],
+        ["thread.user_response", (m) => handleUserResponse.call(turnControlHost(host), m)],
+        ["thread.list", (m) => handleThreadList.call(sessionHost(host), m)],
+        ["session.resume", (m) => handleSessionResume.call(sessionHost(host), m)],
+        ["thread.create", (m) => handleThreadCreate.call(sessionHost(host), m)],
+        ["session.getInfo", (m) => handleSessionGetInfo.call(sessionHost(host), m)],
+        ["session.create", (m) => handleSessionCreate.call(sessionHost(host), m)],
+        ["session.resolve", (m) => handleSessionResolve.call(sessionHost(host), m)],
+        ["session.list", (m) => handleSessionList.call(sessionHost(host), m)],
+        ["session.get", (m) => handleSessionGet.call(sessionHost(host), m)],
+        ["session.getMessages", (m) => handleSessionGetMessages.call(sessionHost(host), m)],
+        ["session.update", (m) => handleSessionUpdate.call(sessionHost(host), m)],
+        ["session.delete", (m) => handleSessionDelete.call(sessionHost(host), m)],
+        ["session.deleteAll", (m) => handleSessionDeleteAll.call(sessionHost(host), m)],
+        ["session.archive", (m) => handleSessionArchive.call(sessionHost(host), m)],
+        ["memory.list", (m) => handleMemoryList.call(memoryHost(host), m)],
+        ["memory.atlas", (m) => handleMemoryAtlas.call(memoryHost(host), m)],
+        ["memory.activity", (m) => handleMemoryActivity.call(memoryHost(host), m)],
+        ["memory.observe", (m) => handleMemoryObserve.call(memoryHost(host), m)],
+        ["memory.propose", (m) => handleMemoryPropose.call(memoryHost(host), m)],
+        ["memory.consolidate", (m) => handleMemoryConsolidate.call(memoryHost(host), m)],
+        ["memory.read", (m) => handleMemoryRead.call(memoryHost(host), m)],
+        ["memory.write", (m) => handleMemoryWrite.call(memoryHost(host), m)],
+        ["memory.search", (m) => handleMemorySearch.call(memoryHost(host), m)],
+        ["memory.delete", (m) => handleMemoryDelete.call(memoryHost(host), m)],
+        ["memory.update", (m) => handleMemoryUpdate.call(memoryHost(host), m)],
+        ["memory.attachment.adopt", (m) => handleMemoryAttachmentAdopt.call(memoryHost(host), m)],
+        ["memory.attachment.locate", (m) => handleMemoryAttachmentLocate.call(memoryHost(host), m)],
+        ["tools.list", (m) => handleToolsList.call(configHost(host), m)],
+        ["media.listModels", (m) => handleMediaListModels.call(mediaHost(host), m)],
+        ["media.cancel", (m) => handleMediaCancel.call(mediaHost(host), m)],
+        ["media.status", (m) => handleMediaStatus.call(mediaHost(host), m)],
+        ["media.stt", (m) => handleMediaStt.call(mediaHost(host), m)],
+        ["settings.listProviders", (m) => handleSettingsListProviders.call(settingsHost(host), m)],
+        ["settings.addKey", (m) => handleSettingsAddKey.call(settingsHost(host), m)],
+        ["settings.removeKey", (m) => handleSettingsRemoveKey.call(settingsHost(host), m)],
+        ["settings.getKey", (m) => handleSettingsGetKey.call(settingsHost(host), m)],
+        ["settings.copyKey", (m) => handleSettingsCopyKey.call(settingsHost(host), m)],
+        ["settings.toggleKey", (m) => handleSettingsToggleKey.call(settingsHost(host), m)],
+        ["settings.toggleModel", (m) => handleSettingsToggleModel.call(settingsHost(host), m)],
+        ["settings.listModels", (m) => handleSettingsListModels.call(settingsHost(host), m)],
+        ["settings.setActiveModel", (m) => handleSettingsSetActiveModel.call(settingsHost(host), m)],
+        ["settings.getActiveModel", (m) => handleSettingsGetActiveModel.call(settingsHost(host), m)],
+        ["settings.getOverview", (m) => handleSettingsGetOverview.call(settingsHost(host), m)],
+        ["settings.refreshModels", (m) => handleSettingsRefreshModels.call(settingsHost(host), m)],
+        ["settings.validateKey", (m) => handleSettingsValidateKey.call(settingsHost(host), m)],
+        ["provider.list", (m) => handleProviderList.call(configHost(host), m)],
+        ["config.get", (m) => handleConfigGet.call(configHost(host), m)],
+        ["config.update", (m) => handleConfigUpdate.call(configHost(host), m)],
+        ["config.tunables", (m) => handleConfigTunables.call(configHost(host), m)],
+        ["config.updateTunable", (m) => handleConfigUpdateTunable.call(configHost(host), m)],
+        ["community.getConsent", (m) => handleCommunityGetConsent.call(communityHost(host), m)],
+        ["community.setConsent", (m) => handleCommunitySetConsent.call(communityHost(host), m)],
+        ["community.matchRegistry", (m) => handleCommunityMatchRegistry.call(communityHost(host), m)],
+        ["community.listShared", (m) => handleCommunityListShared.call(communityHost(host), m)],
+        ["community.withdrawShared", (m) => handleCommunityWithdrawShared.call(communityHost(host), m)],
+        ["community.withdrawAllShared", (m) => handleCommunityWithdrawAllShared.call(communityHost(host), m)],
+        ["community.listNotices", (m) => handleCommunityListNotices.call(communityHost(host), m)],
+        ["community.markNoticeRead", (m) => handleCommunityMarkNoticeRead.call(communityHost(host), m)],
+        ["community.listPublishAudit", (m) => handleCommunityListPublishAudit.call(communityHost(host), m)],
+        ["community.resolveInstall", (m) => handleCommunityResolveInstall.call(communityHost(host), m)],
+        ["community.installResource", (m) => handleCommunityInstallResource.call(communityHost(host), m)],
+        ["community.runtimeStatus", (m) => handleCommunityRuntimeStatus.call(communityHost(host), m)],
+        ["community.installRuntime", (m) => handleCommunityInstallRuntime.call(communityHost(host), m)],
+        ["community.publishSkill", (m) => handleCommunityPublishSkill.call(communityHost(host), m)],
+        ["community.publishPet", (m) => handleCommunityPublishPet.call(communityHost(host), m)],
+        ["community.recordSignal", (m) => handleCommunityRecordSignal.call(communityHost(host), m)],
+        ["community.recordTelemetry", (m) => handleCommunityRecordTelemetry.call(communityHost(host), m)],
+        ["todos.list", (m) => handleTodosList.call(configHost(host), m)],
+        ["tasks.list", (m) => handleTasksList.call(configHost(host), m)],
+        ["tasks.cancel", (m) => handleTasksCancel.call(configHost(host), m)],
+        ["agents.scan", (m) => handleAgentsScan.call(agentsHost(host), m)],
+        ["agents.list", (m) => handleAgentsList.call(agentsHost(host), m)],
+        ["agents.catalog", (m) => handleAgentsCatalog.call(agentsHost(host), m)],
+        ["agents.install", (m) => handleAgentsInstall.call(agentsHost(host), m)],
+        ["agents.prompt", (m) => handleAgentsPrompt.call(agentsHost(host), m)],
+        ["agents.approvalResponse", (m) => handleAgentsApprovalResponse.call(agentsHost(host), m)],
+        ["agents.warm", (m) => handleAgentsWarm.call(agentsHost(host), m)],
+        ["agents.config", (m) => handleAgentsConfig.call(agentsHost(host), m)],
+        ["agents.setConfig", (m) => handleAgentsSetConfig.call(agentsHost(host), m)],
+        ["agents.getConfig", (m) => handleAgentsGetConfig.call(agentsHost(host), m)],
+        ["agents.removeConfig", (m) => handleAgentsRemoveConfig.call(agentsHost(host), m)],
+        ["agents.setGateway", (m) => handleAgentsSetGateway.call(agentsHost(host), m)],
+        ["agents.getGateway", (m) => handleAgentsGetGateway.call(agentsHost(host), m)],
+        ["agents.processes", (m) => handleAgentsProcesses.call(agentsHost(host), m)],
+        ["agents.kill", (m) => handleAgentsKill.call(agentsHost(host), m)],
+        ["agents.listConfigured", (m) => handleAgentsListConfigured.call(agentsHost(host), m)],
+        ["agents.getLog", (m) => handleAgentsGetLog.call(agentsHost(host), m)],
+        ["agents.testConnection", (m) => handleAgentsTestConnection.call(agentsHost(host), m)],
+        ["solo.start", (m) => handleSoloStart.call(soloHost(host), m)],
+        ["solo.status", (m) => handleSoloStatus.call(soloHost(host), m)],
+        ["solo.cancel", (m) => handleSoloCancel.call(soloHost(host), m)],
+        ["solo.select", (m) => handleSoloSelect.call(soloHost(host), m)],
+        ["solo.list", (m) => handleSoloList.call(soloHost(host), m)],
+        ["solo.delete", (m) => handleSoloDelete.call(soloHost(host), m)],
+        ["solo.message", (m) => handleSoloMessage.call(soloHost(host), m)],
+        ["solo.evaluate", (m) => handleSoloEvaluate.call(soloHost(host), m)],
+        ["product.plan", (m) => handleProductPlan.call(productHost(host), m)],
+        ["product.confirm", (m) => handleProductConfirm.call(productHost(host), m)],
+        ["product.message", (m) => handleProductMessage.call(productHost(host), m)],
+        ["product.create", (m) => handleProductCreate.call(productHost(host), m)],
+        ["product.resume", (m) => handleProductResume.call(productHost(host), m)],
+        ["product.pause", (m) => handleProductPause.call(productHost(host), m)],
+        ["product.checkpoint", (m) => handleProductCheckpoint.call(productHost(host), m)],
+        ["product.status", (m) => handleProductStatus.call(productHost(host), m)],
+        ["product.list", (m) => handleProductList.call(productHost(host), m)],
+        ["product.delete", (m) => handleProductDelete.call(productHost(host), m)],
+        ["product.cancel", (m) => handleProductCancel.call(productHost(host), m)],
+        ["product.rollback", (m) => handleProductRollback.call(productHost(host), m)],
+        ["workflow.create", (m) => handleWorkflowCreate.call(workflowHost(host), m)],
+        ["workflow.get", (m) => handleWorkflowGet.call(workflowHost(host), m)],
+        ["workflow.describe", (m) => handleWorkflowDescribe.call(workflowHost(host), m)],
+        ["workflow.patch", (m) => handleWorkflowPatch.call(workflowHost(host), m)],
+        ["workflow.run", (m) => handleWorkflowRun.call(workflowHost(host), m)],
+        ["workflow.setActive", (m) => handleWorkflowSetActive.call(workflowHost(host), m)],
+        ["workflow.list", (m) => handleWorkflowList.call(workflowHost(host), m)],
+        ["workflow.delete", (m) => handleWorkflowDelete.call(workflowHost(host), m)],
+        ["workflow.onImMessage", (m) => handleWorkflowOnImMessage.call(workflowHost(host), m)],
+        ["workflow.onWebhook", (m) => handleWorkflowOnWebhook.call(workflowHost(host), m)],
+        ["workflow.revisions", (m) => handleWorkflowRevisions.call(workflowHost(host), m)],
+        ["workflow.revert", (m) => handleWorkflowRevert.call(workflowHost(host), m)],
+        ["workflow.runs", (m) => handleWorkflowRuns.call(workflowHost(host), m)],
+        ["workflow.runDetail", (m) => handleWorkflowRunDetail.call(workflowHost(host), m)],
+        ["workflow.export", (m) => handleWorkflowExport.call(workflowHost(host), m)],
+        ["workflow.import", (m) => handleWorkflowImport.call(workflowHost(host), m)],
+        ["workflow.duplicate", (m) => handleWorkflowDuplicate.call(workflowHost(host), m)],
+        ["workflow.update", (m) => handleWorkflowUpdate.call(workflowHost(host), m)],
+        ["workflow.capabilities", (m) => handleWorkflowCapabilities.call(workflowHost(host), m)],
+        ["workflow.onIntent", (m) => handleWorkflowOnIntent.call(workflowHost(host), m)],
+        ["workflow.intentIndex", (m) => handleWorkflowIntentIndex.call(workflowHost(host), m)],
+        ["workflow.cancelRun", (m) => handleWorkflowCancelRun.call(workflowHost(host), m)],
+        ["workflow.setPermissionScope", (m) => handleWorkflowSetPermissionScope.call(workflowHost(host), m)],
+        ["workflow.publish", (m) => handleWorkflowPublish.call(workflowHost(host), m)],
+        ["workflow.publishHub", (m) => handleWorkflowPublishHub.call(workflowHost(host), m)],
+        ["workflow.audit", (m) => handleWorkflowAudit.call(workflowHost(host), m)],
+        ["workflow.archive", (m) => handleWorkflowArchive.call(workflowHost(host), m)],
+        ["workflow.dryRun", (m) => handleWorkflowDryRun.call(workflowHost(host), m)],
+        ["workflow.metrics", (m) => handleWorkflowMetrics.call(workflowHost(host), m)],
+        ["workflow.approve", (m) => handleWorkflowApprove.call(workflowHost(host), m)],
+        ["workflow.approvals", (m) => handleWorkflowApprovals.call(workflowHost(host), m)],
+        ["workflow.onForm", (m) => handleWorkflowOnForm.call(workflowHost(host), m)],
+        ["credential.list", (m) => handleCredentialList.call(workflowHost(host), m)],
+        ["credential.create", (m) => handleCredentialCreate.call(workflowHost(host), m)],
+        ["credential.delete", (m) => handleCredentialDelete.call(workflowHost(host), m)],
+        ["credential.oauthStart", (m) => handleCredentialOauthStart.call(workflowHost(host), m)],
+        ["credential.oauthComplete", (m) => handleCredentialOauthComplete.call(workflowHost(host), m)],
+        ["project.create", (m) => handleProjectCreate.call(projectHost(host), m)],
+        ["project.list", (m) => handleProjectList.call(projectHost(host), m)],
+        ["project.delete", (m) => handleProjectDelete.call(projectHost(host), m)],
+        ["project.purgeAll", (m) => handleProjectPurgeAll.call(projectHost(host), m)],
+        ["project.rename", (m) => handleProjectRename.call(projectHost(host), m)],
+        ["project.archive", (m) => handleProjectArchive.call(projectHost(host), m)],
+        ["project.unarchive", (m) => handleProjectUnarchive.call(projectHost(host), m)],
+        ["project.update", (m) => handleProjectUpdate.call(projectHost(host), m)],
+        ["project.archiveByGroup", (m) => handleProjectArchiveByGroup.call(projectHost(host), m)],
+        ["session.switchProject", (m) => handleSessionSwitchProject.call(sessionHost(host), m)],
+        ["session.focus", (m) => handleSessionFocus.call(sessionHost(host), m)],
+        ["session.moveToProject", (m) => handleSessionMoveToProject.call(sessionHost(host), m)],
+        ["session.getState", (m) => handleSessionGetState.call(sessionHost(host), m)],
+        ["files.list", (m) => handleFilesList.call(filesHost(host), m)],
+        ["files.create", (m) => handleFilesCreate.call(filesHost(host), m)],
+        ["files.read", (m) => handleFilesRead.call(filesHost(host), m)],
+        ["files.rename", (m) => handleFilesRename.call(filesHost(host), m)],
+        ["files.delete", (m) => handleFilesDelete.call(filesHost(host), m)],
+        ["files.gitStatus", (m) => handleFilesGitStatus.call(filesHost(host), m)],
+        ["instructions.list", (m) => handleInstructionsList.call(filesHost(host), m)],
+        ["instructions.read", (m) => handleInstructionsRead.call(filesHost(host), m)],
+        ["instructions.write", (m) => handleInstructionsWrite.call(filesHost(host), m)],
+        ["instructions.delete", (m) => handleInstructionsDelete.call(filesHost(host), m)],
+        ["plans.list", (m) => handlePlansList.call(filesHost(host), m)],
+        ["skills.list", (m) => handleSkillsList.call(skillsHost(host), m)],
+        ["skills.activate", (m) => handleSkillsActivate.call(skillsHost(host), m)],
+        ["skills.deactivate", (m) => handleSkillsDeactivate.call(skillsHost(host), m)],
+        ["skills.delete", (m) => handleSkillsDelete.call(skillsHost(host), m)],
+        ["skills.promote", (m) => handleSkillsPromote.call(skillsHost(host), m)],
+        ["skills.stats", (m) => handleSkillsStats.call(skillsHost(host), m)],
+        ["skills.pin", (m) => handleSkillsPin.call(skillsHost(host), m)],
+        ["skills.unpin", (m) => handleSkillsUnpin.call(skillsHost(host), m)],
+        ["skills.curator", (m) => handleSkillsCurator.call(skillsHost(host), m)],
+        ["skills.lifecycle", (m) => handleSkillsLifecycle.call(skillsHost(host), m)],
+        ["pet.interact", (m) => handlePetInteract.call(petHost(host), m)],
+        ["pet.status", (m) => handlePetStatus.call(petHost(host), m)],
+        ["pet.forge", (m) => handlePetForge.call(petHost(host), m)],
+        ["pet.asset.import", (m) => handlePetAssetImport.call(petHost(host), m)],
+        ["pet.preferences.update", (m) => handlePetPreferencesUpdate.call(petHost(host), m)],
+        ["pet.journey.snapshot", (m) => handlePetJourneySnapshot.call(petHost(host), m)],
+        ["pet.journey.list", (m) => handlePetJourneyList.call(petHost(host), m)],
+        ["pet.journey.get", (m) => handlePetJourneyGet.call(petHost(host), m)],
+        ["pet.custom.delete", (m) => handlePetCustomDelete.call(petHost(host), m)],
+        ["pet.confirm_response", (m) => handlePetConfirmResponse.call(petConfirmHost(host), m)],
+    ]);
+}

package/dist/cli/runtime-dependency-catalog.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Vetted runtime-dependency catalog for community skills.
+ *
+ * A skill manifest may declare `runtime: ["officecli"]` — bare ids only. The
+ * registry stays declarative: WHAT a skill needs lives in Hub data, but HOW to
+ * probe/install it lives here, reviewed in code. The installer never executes
+ * anything from registry payloads, so a compromised registry row cannot turn
+ * "install skill" into arbitrary code execution; unknown ids surface as
+ * "manual" in the handshake UI instead of running anything.
+ */
+export interface RuntimeDependencySpec {
+    id: string;
+    /** Human-facing name shown in the handshake card. */
+    label: string;
+    /** Executable probed on PATH (and `extraWindowsPaths` fallbacks). */
+    bin: string;
+    probeArgs: string[];
+    /** Known install locations not yet on PATH in this process (fresh installs). */
+    extraWindowsPaths?: string[];
+    /**
+     * quick=true → the handshake auto-installs without an extra consent step
+     * (small, single-artifact, official installer). quick=false → the client
+     * must show a consent card first (large download / system-level changes).
+     */
+    quick: boolean;
+    /** Honest size estimate surfaced in the consent card. */
+    estSizeMB: number;
+    install: Partial<Record<"win32" | "default", {
+        command: string;
+        args: string[];
+    }>>;
+    installTimeoutMs: number;
+    docsUrl?: string;
+}
+export declare const RUNTIME_DEPENDENCIES: Record<string, RuntimeDependencySpec>;
+export interface RuntimeDependencyStatus {
+    id: string;
+    /** false → not in the vetted catalog: the client can only show guidance. */
+    known: boolean;
+    label?: string;
+    present: boolean;
+    version?: string;
+    /** Absolute path when found via a known location instead of PATH. */
+    binPath?: string;
+    quick?: boolean;
+    estSizeMB?: number;
+    docsUrl?: string;
+}
+export declare function probeRuntimeDependency(id: string): Promise<RuntimeDependencyStatus>;
+export interface RuntimeInstallResult {
+    id: string;
+    ok: true;
+    version?: string;
+    binPath?: string;
+}
+export declare function installRuntimeDependency(id: string): Promise<RuntimeInstallResult>;

package/dist/cli/runtime-dependency-catalog.js

@@ -0,0 +1,110 @@
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { execFile, spawn } from "node:child_process";
+export const RUNTIME_DEPENDENCIES = {
+    officecli: {
+        id: "officecli",
+        label: "OfficeCLI 文档引擎",
+        bin: "officecli",
+        probeArgs: ["--version"],
+        extraWindowsPaths: [
+            path.join(process.env.LOCALAPPDATA ?? "", "OfficeCLI", "officecli.exe"),
+        ],
+        quick: true,
+        estSizeMB: 50,
+        install: {
+            win32: {
+                command: "powershell",
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", "irm https://d.officecli.ai/install.ps1 | iex"],
+            },
+            default: {
+                command: "bash",
+                args: ["-lc", "curl -fsSL https://d.officecli.ai/install.sh | bash"],
+            },
+        },
+        installTimeoutMs: 240_000,
+        docsUrl: "https://github.com/iOfficeAI/OfficeCLI",
+    },
+};
+const PROBE_TIMEOUT_MS = 10_000;
+export async function probeRuntimeDependency(id) {
+    const spec = RUNTIME_DEPENDENCIES[id];
+    if (!spec)
+        return { id, known: false, present: false };
+    const meta = { label: spec.label, quick: spec.quick, estSizeMB: spec.estSizeMB, ...(spec.docsUrl ? { docsUrl: spec.docsUrl } : {}) };
+    const onPath = await probeExec(spec.bin, spec.probeArgs);
+    if (onPath.ok)
+        return { id, known: true, present: true, version: onPath.version, ...meta };
+    // Fresh installs land outside this process's PATH (the installer appends to
+    // the user PATH, which only new shells see) — known locations keep the
+    // handshake honest right after installing.
+    if (process.platform === "win32") {
+        for (const candidate of spec.extraWindowsPaths ?? []) {
+            if (!candidate || !existsSync(candidate))
+                continue;
+            const probed = await probeExec(candidate, spec.probeArgs);
+            if (probed.ok)
+                return { id, known: true, present: true, version: probed.version, binPath: candidate, ...meta };
+        }
+    }
+    return { id, known: true, present: false, ...meta };
+}
+export async function installRuntimeDependency(id) {
+    const spec = RUNTIME_DEPENDENCIES[id];
+    if (!spec) {
+        throw new Error(`Runtime dependency "${id}" is not in the vetted catalog; refusing to run anything.`);
+    }
+    const recipe = (process.platform === "win32" ? spec.install.win32 : spec.install.default) ?? spec.install.default;
+    if (!recipe) {
+        throw new Error(`Runtime dependency "${spec.label}" has no installer for ${process.platform}.`);
+    }
+    const output = await runInstaller(recipe.command, recipe.args, spec.installTimeoutMs);
+    const status = await probeRuntimeDependency(id);
+    if (!status.present) {
+        const tail = output.trim().split(/\r?\n/).slice(-6).join("\n");
+        throw new Error(`${spec.label} 安装后仍未检测到可执行文件。安装输出(末尾):\n${tail || "(无输出)"}`);
+    }
+    return { id, ok: true, ...(status.version ? { version: status.version } : {}), ...(status.binPath ? { binPath: status.binPath } : {}) };
+}
+function probeExec(command, args) {
+    return new Promise((resolve) => {
+        execFile(command, args, { timeout: PROBE_TIMEOUT_MS, windowsHide: true }, (err, stdout, stderr) => {
+            if (err) {
+                resolve({ ok: false });
+                return;
+            }
+            const firstLine = `${stdout || stderr}`.trim().split(/\r?\n/)[0]?.trim();
+            resolve({ ok: true, ...(firstLine ? { version: firstLine.slice(0, 120) } : {}) });
+        });
+    });
+}
+function runInstaller(command, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        let output = "";
+        const capture = (chunk) => {
+            output += chunk.toString("utf8");
+            if (output.length > 64_000)
+                output = output.slice(-32_000);
+        };
+        child.stdout?.on("data", capture);
+        child.stderr?.on("data", capture);
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            reject(new Error(`安装超时(${Math.round(timeoutMs / 1000)}s)。`));
+        }, timeoutMs);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(output);
+                return;
+            }
+            const tail = output.trim().split(/\r?\n/).slice(-6).join("\n");
+            reject(new Error(`安装进程退出码 ${code}。输出(末尾):\n${tail || "(无输出)"}`));
+        });
+    });
+}

package/dist/cli/runtime-hook-bootstrap.d.ts

@@ -0,0 +1,38 @@
+import type { AgentLogger } from "../agent/types.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import type { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
+import type { TaskStore } from "../runtime/infra/task-runtime.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, MemoryLearningSink, ProjectMemoryStore, ToolCatalog } from "../runtime/ports/index.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface RuntimeHookBootstrapDeps {
+    log: AgentLogger;
+    taskStore: TaskStore;
+    backgroundTasks: BackgroundTaskManager;
+    sessionId: string;
+    projectRoot: string;
+    memdir: ProjectMemoryStore;
+    toolCatalog: ToolCatalog;
+    currentUserId: string;
+    prefetchState: MemoryPrefetchState;
+    getLastUserMessage(): string | undefined;
+    getLastAssistantMessage(): string | undefined;
+    resolveSmallModelClient(): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+    compressionClient: {
+        transport: LLMTransport;
+        apiKey: string;
+    };
+    sendNotification?(method: string, params: Record<string, unknown>): void;
+}
+export interface RuntimeHookBootstrapResult {
+    hooks: HookRegistry;
+    memoryHandlerProvider: MemoryHandlerProvider | null;
+    memoryDreamProvider: MemoryDreamRuntimeProvider | null;
+    memoryLearningSink: MemoryLearningSink | null;
+    memoryUserId: string;
+}
+export declare function configureRuntimeHookBootstrap(deps: RuntimeHookBootstrapDeps): RuntimeHookBootstrapResult;

package/dist/cli/runtime-hook-bootstrap.js

@@ -0,0 +1,71 @@
+import { registerContextCompressionHook } from "../runtime/hooks/context-compression.js";
+import { createDefaultCommunityConsentClient } from "../runtime/community/community-consent-client.js";
+import { CommunityDiscoveryCoordinator } from "../runtime/community/community-discovery-coordinator.js";
+import { createHookRegistry } from "../runtime/hooks/hook-registry.js";
+import { registerMemdirRecallHook } from "../runtime/hooks/memory-hooks.js";
+import { registerSkillRecallHooks } from "../runtime/hooks/skill-recall-hooks.js";
+import { registerMemoryRuntimeHooks, registerMemoryTool } from "./memory-coordinator.js";
+import { setBackgroundTaskRuntime, setTaskToolHooks } from "./tool-bootstrap.js";
+export function configureRuntimeHookBootstrap(deps) {
+    const hooks = createHookRegistry(deps.log);
+    deps.taskStore.setHooks(hooks, deps.sessionId);
+    // Bind the unified background task registry into tool-bootstrap so
+    // exec(background=true) and the task tool's output/cancel actions work.
+    setBackgroundTaskRuntime(deps.backgroundTasks);
+    setTaskToolHooks({
+        onTaskCreated: (task) => {
+            hooks.invoke("task.created", {
+                sessionId: deps.sessionId,
+                taskId: String(task.id),
+                taskType: "planning",
+                label: task.title,
+            }).catch(() => { });
+        },
+        onTaskCompleted: (task) => {
+            hooks.invoke("task.completed", {
+                sessionId: deps.sessionId,
+                taskId: String(task.id),
+                taskType: "planning",
+                label: task.title,
+            }).catch(() => { });
+        },
+    });
+    const memoryState = registerMemoryRuntimeHooks({
+        hooks,
+        currentUserId: deps.currentUserId,
+        log: deps.log,
+        prefetchState: deps.prefetchState,
+        getLastUserMessage: deps.getLastUserMessage,
+        getLastAssistantMessage: deps.getLastAssistantMessage,
+        resolveSmallModelClient: deps.resolveSmallModelClient,
+    });
+    registerSkillRecallHooks(hooks, {
+        currentCwd: deps.projectRoot,
+        communityDiscovery: new CommunityDiscoveryCoordinator({
+            client: createDefaultCommunityConsentClient(),
+        }),
+        log: { debug: (m) => deps.log.debug(m), warn: (m) => deps.log.warn(m) },
+    });
+    registerContextCompressionHook(hooks, deps.log, {
+        transport: deps.compressionClient.transport,
+        apiKey: deps.compressionClient.apiKey,
+    });
+    registerMemoryTool({
+        memdir: deps.memdir,
+        memoryProvider: memoryState.toolProvider,
+        memoryUserId: memoryState.userId,
+        toolCatalog: deps.toolCatalog,
+        sendNotification: deps.sendNotification,
+    });
+    registerMemdirRecallHook(hooks, {
+        getMemorySource: () => deps.memdir,
+        log: { debug: (m) => deps.log.debug(m), warn: (m) => deps.log.warn(m) },
+    }, deps.prefetchState);
+    return {
+        hooks,
+        memoryHandlerProvider: memoryState.handlerProvider,
+        memoryDreamProvider: memoryState.dreamProvider,
+        memoryLearningSink: memoryState.learningSink,
+        memoryUserId: memoryState.userId,
+    };
+}

package/dist/cli/runtime-watcher-bootstrap.d.ts

@@ -0,0 +1,15 @@
+import type { AgentLogger } from "../agent/types.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import { type FileWatcher } from "../runtime/infra/file-watcher.js";
+import type { PermissionRuleEnginePort } from "../runtime/ports/index.js";
+export type { FileWatcher };
+export interface RuntimeWatcherBootstrapDeps {
+    config: Record<string, unknown>;
+    hooks: HookRegistry;
+    ruleEngine: PermissionRuleEnginePort;
+    sessionId: string;
+    currentFileWatcher: FileWatcher | null;
+    log: AgentLogger;
+    setFileWatcher(watcher: FileWatcher | null): void;
+}
+export declare function configureRuntimeWatchers(deps: RuntimeWatcherBootstrapDeps): void;

package/dist/cli/runtime-watcher-bootstrap.js

@@ -0,0 +1,30 @@
+import { createFileWatcher } from "../runtime/infra/file-watcher.js";
+import { registerCleanup } from "../runtime/infra/cleanup-registry.js";
+import { resetInstructionCache } from "../runtime/prompt/instruction-loader.js";
+import { watchSettings } from "../skills/permissions/settings-watcher.js";
+export function configureRuntimeWatchers(deps) {
+    const projectRoot = typeof deps.config.workdir === "string"
+        ? deps.config.workdir
+        : process.cwd();
+    const stopSettingsWatcher = watchSettings({
+        projectRoot,
+        ruleEngine: deps.ruleEngine,
+        hooks: deps.hooks,
+        log: (message) => deps.log.info(`[settings] ${message}`),
+    });
+    registerCleanup(async () => { stopSettingsWatcher(); });
+    deps.currentFileWatcher?.stop();
+    deps.setFileWatcher(null);
+    createFileWatcher({
+        projectRoot,
+        sessionId: deps.sessionId,
+        hooks: deps.hooks,
+        log: (message) => deps.log.debug(message),
+        onInstructionCacheReset: resetInstructionCache,
+    }).then((watcher) => {
+        deps.setFileWatcher(watcher);
+        registerCleanup(async () => { watcher.stop(); });
+    }).catch((err) => {
+        deps.log.warn(`[file-watcher] init error: ${err instanceof Error ? err.message : err}`);
+    });
+}

package/dist/cli/session-context.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SessionContext — the active session/turn identity + lifecycle state.
+ *
+ * The "who/what is running right now" the server tracks across the current session
+ * and turn: the session id, the in-flight turn id, the session cost/state snapshot,
+ * sticky task domain, host-pinned LLM config, and the ACP session _meta supplement.
+ *
+ * Extracted from StdioServer so its runtime-state-container concern is one named
+ * holder rather than six loose fields on the god-object. It is a plain mutable
+ * holder (no invariant beyond field cohesion); the server exposes same-named
+ * get/set accessors that delegate here, so every existing reader AND writer —
+ * including handlers bound via the RPC host cast (session.create, thread.turn,
+ * set_config) — keeps working unchanged.
+ */
+import type { SessionState } from "../runtime/session/session-state.js";
+import type { SessionLlmConfig } from "./acp-session-host.js";
+import type { TaskDomain } from "../runtime/prompt/task-domain.js";
+export declare class SessionContext {
+    /** Active session id (chatId for desktop; group key pattern for groups). */
+    sessionId: string;
+    /** In-flight turn id. */
+    turnId: string;
+    /** Session cost/state snapshot (null until a session is resolved). */
+    state: SessionState | null;
+    /** Session-level task domain stickiness — survives across turns within a session. */
+    taskDomain: TaskDomain | undefined;
+    /** Host-pinned per-session LLM config (session/set_config_option · set_model · /model).
+     *  NEVER wiped by ModelRegistry churn — distinct from the DERIVED ResolvedAgentCache. */
+    llmConfig: SessionLlmConfig;
+    /** ACP session-level context supplement (_meta from session/new), inherited by every prompt. */
+    acpMeta: Record<string, unknown> | null;
+}

package/dist/cli/session-context.js

@@ -0,0 +1,15 @@
+export class SessionContext {
+    /** Active session id (chatId for desktop; group key pattern for groups). */
+    sessionId = "";
+    /** In-flight turn id. */
+    turnId = "";
+    /** Session cost/state snapshot (null until a session is resolved). */
+    state = null;
+    /** Session-level task domain stickiness — survives across turns within a session. */
+    taskDomain;
+    /** Host-pinned per-session LLM config (session/set_config_option · set_model · /model).
+     *  NEVER wiped by ModelRegistry churn — distinct from the DERIVED ResolvedAgentCache. */
+    llmConfig = {};
+    /** ACP session-level context supplement (_meta from session/new), inherited by every prompt. */
+    acpMeta = null;
+}