qlogicagent 2.13.5 → 2.13.6

package/dist/cli/rpc-registry.js

@@ -1,243 +0,0 @@
-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

@@ -1,56 +0,0 @@
-/**
- * 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

@@ -1,110 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,15 +0,0 @@
-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;
-}