Capability Seams And Core Services

A service can be a core spine service, a swappable capability seam, a bundle/composition point, or a standalone service. The graph shows the package that owns the service declaration, known implementation packages, and packages that consume the service directly.

ctx key	Role	Owner	Implementations	Direct consumers	Companion plugins	Note
ctx.actionCards	service	action-cards	-	creation-recommendations, client-ui-action-cards	-	Owns the card tool, card state, user actions and status notices; card kinds register their actions and handlers.
ctx.pluginRecommendations	service	plugin-recommendations	-	client-ui-plugin-recommendations	-	Reads the current catalog text of an official plugin card and enables the plugin through the profile plugin manager after a click.
ctx.headlessStartup	core	headless	-	headless	-	Supplies parsed task and run options to the headless runner and its sandbox-policy configuration.
ctx.cotTranslation	service	experimental-client-ui-cot-translation	-	-	-	Serves reasoning translations, reuses saved results, and joins ordinary Session activation for uncached inactive Sessions.
ctx.translator	service	experimental-translator	-	experimental-client-ui-cot-translation	-	Resolves Google or Bing requests and retains shared experimental records through the active Session writer.
ctx.hmr	core	hmr	-	app-boot	-	Owns module and exact configuration watchers; application mutations share its queue and automatic reloads await the application file lock.
ctx.pluginRegistryProbe	core	client-ui-plugin-manager	-	client-ui-plugin-manager	-	Races public registry responses on the Host; the Client owns the initial registry recommendation.
ctx.pluginManager	core	plugin-manager	-	plugin-manager, ui-settings-plugin-inventory	-	Shares profile package operations with the CLI and reports persisted and running state to Web and agent callers.
ctx.pluginMarket	core	plugin-market	-	client-ui-plugin-market, plugin-market	-	Fetches and validates the index sources the user configures; installation goes through the plugin manager.
ctx.profileContext	core	app-boot	-	plugin-manager	-	The dsh launcher supplies data-only profile locations and composition inputs; reload scheduling belongs to dsh-hmr.
ctx.connection	core	client-connection	-	api-gateway, host-frontend-static	-	Owns browser authentication and shared HTTP request dispatch; API adapters register endpoints and streams.
ctx.forge	seam	experimental-forge	experimental-forge-github	experimental-forge-session, experimental-client-ui-forge	-	Providers map remote and change request URLs, look up change requests by head branch, and read status in batches; watchers of one change request share one polling loop.
ctx.forgeSession	service	experimental-forge-session	-	experimental-client-ui-forge	-	A Session projection derives bindings from shell results and binding records and publishes their URLs without status to clients; push results trigger head-branch discovery, and Session watchers poll bound change requests through the forge registry.
ctx.forgePanel	service	experimental-client-ui-forge	-	-	-	Streams one panel state per followed Session: Git inspection using Session permissions, the recognized code host and its sign-in, and the bound change requests with polled status.
ctx.worktrees	seam	experimental-worktree	experimental-worktree	experimental-tool-worktree	-	Explicit experimental creation from a pinned local commit. Existing write permissions govern checkout and shared Git metadata; the working-directory service owns the resulting Session directory.
ctx.workingDirectory	seam	working-directory	working-directory	tool-working-directory, tool-fs, tool-bash, tool-pwsh, subagent, sdk-jsonrpc-server	-	One Session projection owns the effective execution directory. The filesystem validates changes; user context reports them while original metadata and write grants stay fixed.
ctx.mcpResources	seam	mcp-resources	mcp-client	mcp-resources	-	Connection-owned providers serve shared resource tools in the calling agent scope.
ctx.browserUse	seam	browser-use	experimental-browser-use-playwright-mcp, experimental-browser-use-chrome-devtools-mcp, experimental-browser-use-stagehand-native	experimental-browser-use-playwright-mcp, experimental-browser-use-chrome-devtools-mcp, experimental-browser-use-stagehand-native	-	One provider-owned name per service instance. Providers own their tools and browser resources per live Session; the shared service has no browser operation API.
ctx.computerUse	seam	computer-use	experimental-computer-use-cua-driver-mcp, experimental-computer-use-cua-driver-native	experimental-computer-use-cua-driver-mcp, experimental-computer-use-cua-driver-native	-	One provider-owned name per service instance. Each provider also owns its model tools; the service has no common action API, runtime selection, or Session workflow lock.
ctx.cuaAccess	core	cua	-	cua	-	The native provider owns application consent and cancellation; the optional Client page queries and changes those decisions through its Remote.
ctx.officeKit	core	office-kit	-	client-ui-sidebar-documentpreview, tool-office	-	Authorized Office bytes are rendered as PDFs or images, converted, or recalculated on the Host using the declared native target engine, or Node WASM when no native target is declared.
ctx.attachments	seam	attachment	attachment-local	api-session-controller, tool-fs, llm-pi-ai, llm-deepseek	-	The host commits accepted images before session events; provider adapters resolve authorized durable references into provider-native content.
ctx.fileUploads	core	client-file-upload	-	api-session-controller	-	Owns streaming intake, durable storage, and staged receipt lifetime; the Session controller binds receipts to accepted submissions.
ctx.llm	seam	llm	llm-deepseek, llm-pi-ai, llm-replay	agent-loop, compaction-basic	-	Adapters register provider implementations; the loop and compaction call the provider-neutral stream service.
ctx.sessionLogDeepSeek	core	session-log-deepseek	-	-	-	Plugins register caller-owned exclusions before the canonical Session-log request contribution is prepared; unmatched requests use normal upload eligibility.
ctx.deepseekLlmApiExtensions	seam	deepseek-llm-api-extensions	session-log-deepseek, plugin-package-inventory-deepseek	llm-deepseek	-	Plugins prepare independent top-level fields; the official adapter merges them and commits their delivery state after HTTP acceptance.
ctx.tokenMeter	core	token-meter	-	compaction-basic	-	Owns isolated per-session replay folds; pressure consumers share immutable revisioned measurements.
ctx.toolResultPruner	core	compaction-tool-result-pruner	-	compaction-basic	-	Rewrites oversized current tool results through replayable single-node surface replacements before summary compaction.
ctx.sessions	core	session	-	agent-loop, agent, session-persistence, session-query, session-query-sqlite, subagent, message-feedback	-	Owns append-only Session instances and emits the durable session event feed.
ctx.speechController	core	experimental-api-speech-to-text	-	-	-	Validates bounded browser audio before provider dispatch.
ctx.sessionController	core	api-session-controller	-	-	-	Owns Session commands, cold reads, durable-event following, live control state, model catalogs, workspace opening, and Agent activation policy.
ctx.sessionFileReferences	core	api-session-controller	-	-	-	Delegates file-reference discovery through the Session Controller's established Agent lookup policy.
ctx.sessionSkillCatalog	core	api-session-controller	-	-	-	Lists the Session composition's user-invocable skills without activating a cold Agent.
ctx.jobController	core	api-job-controller	-	-	-	Streams one background job's observation record over the generated Remote namespace; the roster stays on the session control stream.
ctx.credentialsController	core	api-settings-controller	-	-	-	Projects the credential-reference seam onto the generated Remote namespace: batch fan-out, view projection, and refusal mapping live here, not on the seam Definition.
ctx.settingsController	core	api-settings-controller	-	-	-	Projects the user-settings seam onto the generated Remote namespace: the read is always redacted and every refusal is classified here, not on the seam Definition.
ctx.workspaceFiles	core	api-workspace-files	-	-	-	Serves stat, paged text, byte windows, directory listings, and the change feed for files inside a Session's workspace root, confined by lstat, containment, and a stat re-check.
ctx.workspaceChanges	core	workspace-changes	-	-	-	Serves the summary each workspace/changes event announced and each listed file's turn-start and turn-end comparison, by Session and event sequence, until that Session is disposed; the log carries only the turn.
ctx.terminalController	core	api-terminal-controller	-	-	-	Owns user terminal processes, default shell resolution and bounded screen recovery through the subprocess provider and typed Remote transport.
ctx.workspaceController	core	api-workspace-controller	-	-	-	Owns Workspace commands and reconnect-safe Workspace state delivery through the generated Remote namespace.
ctx.directoryPickerController	core	api-workspace-controller	-	-	-	Carries the picking seam onto the wire: capability gating, cancellation, and the seam-coded failures a browser directory flow discriminates on.
ctx.typert	core	typert-registry	-	typert-loader, api-gateway	-	Plugins register live zod contributions directly or through dsh-typert-loader; the API gateway consumes invocation descriptors and providers, while other runtime consumers query schemas and reflection metadata at their own edges.
ctx.typertGateway	core	api-gateway	-	-	-	Associates generated Remote descriptors with live Cordis services, resolves registered identities, and exposes unary calls through the shared Connection RPC carrier.
ctx.remoteAccess	core	api-remote-access	-	api-gateway, api-session-controller, api-workspace-controller	-	Decides which Remote methods a non-owner Peer may call through business-registered role-based policies, filters list results, and streams each Peer access snapshot.
ctx.sessionPersistence	seam	session-persistence	session-persistence-jsonl	agent-loop, tool-bash, hooks-claude-code, hooks-codex, session-query, session-query-sqlite, message-feedback	-	The JSONL backend persists the SessionEvent vocabulary as one artifact per Session.
ctx.configEditor	core	config-editor	-	settings, agent-default-model	-	Persists profile config patches under the application file lock and HMR queue, then reconciles Loader entries.
ctx.settings	core	settings	-	api-settings-controller	-	Forms project volatile Config fields from active profile entries and delegate validated edits to config-editor. Plugins consume their own Config references.
ctx.subagentModelSelection	core	tool-subagent	-	tool-subagent	-	Owns the default-off settings namespace that Agent-scoped delegation tools sample when composing a new top-level Session.
ctx.credentials	seam	credentials	credentials-local	api-settings-controller, llm-deepseek, llm-pi-ai	-	Configuration carries references to secrets; providers own the values. Consumers resolve per operation, so a rotated credential reaches the very next request; the settings controller exposes value-free views and write-only storage.
ctx.deepseekAccount	service	deepseek-account	-	llm-deepseek	-	The Host owns browser authorization and local credentials; UI consumers receive state without tokens.
ctx.authorization	seam	authorization	-	llm-pi-ai	-	Flows are registered by the plugin that knows how to obtain one credential and keyed by the record they write; the seam owns the conversation and the one-attempt-per-key lifecycle, never the protocol.
ctx.productAnalytics	service	client-product-analytics	-	-	-	Accepts selected Desktop events, enriches available login identity, and observes live compaction under the live Host collection policy.
ctx.otel	service	otel	-	host-product-telemetry-otel, session-telemetry-otel	-	Product analytics and Session feedback adapters create independent reporting channels through one injected service.
ctx.productTelemetry	service	host-product-telemetry-otel	-	-	-	Exports explicitly submitted analytics events through OTLP/HTTP; mounting alone collects nothing.
ctx.sessionTelemetry	seam	session-telemetry	session-telemetry-otel	-	-	The seam captures, redacts, and hands session records to one backend; nothing else consumes the service — its output leaves the process.
ctx.storage	seam	storage	storage-json, storage-sqlite	storage-domain	-	Backends register side by side under names; data forms (domain first) mount on the hub and translate typed operations into opaque KV-unit primitives.
ctx.storageDomain	core	storage-domain	-	workspace	-	Waits for every configured backend, then publishes the domain form as one lifecycle-bound service for typed durable state.
ctx.messageFeedback	core	message-feedback	-	-	-	Owns per-assistant-message feedback in the canonical Session log, target validation, per-item compare-and-set, and the Host unary Remote contract. Feedback stays outside model history; log export follows the consumer policy.
ctx.sessionFeedback	core	command-feedback	-	-	-	Records one Session-level remark with its category as a log-only feedback/record event on a live Session through the Host unary Remote contract; the /feedback command shares the same producer.
ctx.workspaceRegistry	core	workspace	-	api-workspace-controller, api-session-controller	-	Owns WorkspaceId-branded records over the domain facility; stable sessionIds accounts drive Host RPC and GUI projections.
ctx.sessionQuery	seam	session-query	session-query-sqlite	session-reference, tool-session-query	-	The interface supplies exact reads, filters, and traces; its concrete backend adds full-text reconciliation, ranking, snippets, and cursor generations, while the model consumer owns workspace authority and cursor-free rendering.
ctx.fileReferences	seam	file-reference	file-reference-local	api-session-controller	-	The interface returns path-only completion candidates within an Agent cwd; providers own namespace access and ranking without reading file contents.
ctx.sessionReferenceResolver	core	session-reference	-	-	-	Projects bounded current-surface conversation snapshots into durable untrusted message context; host adapters own mention syntax.
ctx.sessionTitle	seam	session-title	session-title-first-prompt-llm, session-title-all-prompts-llm	-	-	Owns the deterministic fallback, latest-title fold, and sole optional asynchronous provider registration.
ctx.systemPrompt	core	system-prompt	-	agent-loop, tools, tool-fs, tool-terminal, tool-web	-	Collects prompt sections and model-facing tool schemas for each step.
ctx.tools	core	tools	-	agent-loop, tool-ask-user, tool-bash, tool-cordis, tool-fs, tool-terminal, tool-skill, tool-subagent, tool-todo, tool-web	-	Registers capabilities and scoped executors. Native and PTC providers own descriptions and complete raw call batches; their optional shared pipeline handles tool policy and dispatch.
ctx.userQuestions	seam	user-questions	-	tool-ask-user	-	UI front ends provide the active human-answer provider; tool-ask-user pauses a tool call on the provider-neutral ask() promise.
ctx.planMode	core	plan-mode	-	-	-	Folds logged plan/mode state, flushes user selections at turn boundaries, renders deployment-owned guidance, registers /plan, and keeps the plan-exit schema stable across transitions.
ctx.agentPresets	core	agent-preset-registry	-	-	-	Eagerly mounts YAML-declared preset revisions, binds Agents and cold readers to scoped contributions, and retains retired revisions until their last user releases them.
ctx.commands	core	commands	-	-	-	Plugins register direct human commands without sending invocations to the model.
ctx.sessionProjections	core	session-projection	-	api-session-controller, tool-todo, session-title	-	Domains register state-driven fold units; the eager drive keeps per-session watermark states and the Session controller serves baselines and pushes changed values.
ctx.sessionProjectionCache	core	session-projection-cache	-	api-session-controller, session-query, session-reference	-	Durably checkpoints projection unit states per session (throttled + turn/end/detach mandatory points), serves cached projection views, and accelerates prepared-Session projection hydration.
ctx.skills	seam	skill	sandbox-windows-acl, skill-badge, skill-filesystem, skill-office	tool-skill	-	Merges provider skill catalogs; tool-skill renders the session-prefix catalog and loads complete skill bodies.
ctx.agents	core	agent	-	agent-loop, acp, subagent	-	Owns live Agent handles, the create/resume factory seam, and process-local initiator propagation.
ctx.agentDefaultModel	core	agent-default-model	-	api-session-controller, headless	-	Reads the default ModelSelection from volatile Config and saves selections through the profile editor.
ctx.agentLoop	bundle	agent-loop	-	base, sdk-minimal	-	The one concrete loop plugin; extension packages depend on dsh-agent events and services, not on this package.
ctx.mcpManager	core	mcp-manager	-	-	-	Reconciles mcp-client instances against its volatile servers configuration, aggregates their connection statuses, and serves restart and probe to management surfaces.
ctx.schedule	core	schedule	-	-	-	Stores tasks independently of Session activation and queues due messages in each task's target Session.
ctx.goals	core	goal	-	-	-	Folds revisioned objective state from the session log and keeps live continuation activation process-local.
ctx.ssh	core	ssh	-	fs-ssh, subprocess-ssh, sandbox-ssh	-	Owns one authenticated OpenSSH connection, installed helper identity, independent program streams and disconnect cleanup for the paired remote providers.
ctx.subprocess	seam	subprocess	subprocess-local, subprocess-ssh	bash-local, bash-sandbox, terminal-bash, lsp-stdio, subagent-acp, subagent-codex, subagent-claude-code	-	The bash executors, the PTY shell backend, the LSP host, and the out-of-process ACP, Codex, and Claude Code subagent backends spawn through ctx.subprocess; the service owns process coordinates, tree/session lifetime, stdio dispositions, terminal mechanics, and kill escalation.
ctx.shell	seam	shell	bash-local, bash-sandbox, pwsh-local	tool-bash, tool-pwsh, hooks-claude-code, hooks-codex	-	The model-facing shell tools and hook bridges consume this seam; sandboxed, remote, or PowerShell executors replace bash-local without touching them.
ctx.shellEnv	core	shell-env	-	tool-bash, tool-pwsh	-	Plugins declare effect-scoped DSH_* facts; each shell tool collects one trusted snapshot per execution and its executor rebuilds the namespace.
ctx.terminals	seam	terminal	terminal-bash, terminal-panel	tool-terminal	-	The registry owns exact-Agent session identity and cleanup; backends own terminal mechanics, while tool-terminal exposes the owner-scoped model tools.
ctx.sandbox	seam	sandbox	sandbox-local, sandbox-ssh	bash-sandbox, terminal-bash, api-terminal-controller	-	Consumers hand over the exact argv they are about to spawn; same-world backends wrap it under a per-call policy and report enforcement.
ctx.sandboxPolicy	core	sandbox-policy	-	bash-sandbox, fs-sandbox, terminal-bash, terminal-panel	-	The one home for the deployment default mode + workspace root; only the sandboxed executor and provider read the service (the tool layers use the pure sandbox/mode fold it also exports). Both enforcing families read it so bash and fs cannot confine to different roots.
ctx.approval	seam	user-approval	-	tools, tool-bash, acp	-	One-shot permission decisions dispatched over the approval/request waterfall; answerers are listeners (the ACP bridge for its own agents), absence fails closed to unavailable.
ctx.permissionPresets	core	permission-presets	-	-	-	User-facing preset table (workspace-write/danger-full-access) bundling the sandbox-mode and approval-policy knobs; a switch writes one permission/preset event through to both knob events.
ctx.ptcRuntime	seam	ptc-runtime	ptc-runtime-node, experimental-ptc-runtime-python	tool-executor-ptc, workflow-ptc	-	Runs programs against host-provided async bindings; tool-executor-ptc owns PTC presentation and workflow-ptc owns workflow orchestration.
ctx.fs	seam	fs	fs-local, fs-sandbox, fs-ssh	tool-fs	fs-observation-policy	tool-fs executes read/write/edit through ctx.fs; fs-sandbox fences mutations by the shared sandbox mode; fs-observation-policy contributes observed-state checks through the fs/* event gate.
ctx.compaction	seam	compaction	compaction-basic	compaction-basic	-	The basic backend consumes post-step pressure and request-error recovery events; there is no model-facing compact tool.
ctx.subagents	seam	subagent	subagent-spawn-in-process, subagent-fork-in-process, subagent-acp, subagent-codex, subagent-claude-code, subagent-dsh-sdk	tool-subagent, tool-subagent-control, tool-ralph	-	Providers prepare local children or execute external tasks; one activation manager owns both lifecycles. The delegation tool selects a backend, control tools deliver local follow-ups, and workflows await activation results.
ctx.speechToText	seam	experimental-speech-to-text	experimental-speech-to-text-sensevoice	experimental-api-speech-to-text	-	Routes explicit recognizers; the browser uses the authenticated Remote and keeps transcripts in the draft until submission.
ctx.agentTeams	core	agent-team	-	tool-agent-team	-	Owns the shared task DAG for a subagent tree; tool-agent-team contributes task controls.
ctx.claudeCodeMods	core	experimental-claude-code-mods	-	-	-	Loads mods that defineMod plugins add, raises their hook chains from harness extension points, and draws the band above the prompt over its Remote.
ctx.inspector	core	inspector	-	-	-	Owns the Worker-hosted CDP target and the transport-independent Host and Client observation and Cordis-tree query API.
ctx.jobs	seam	jobs	jobs-local	tool-bash, tool-pwsh, tool-terminal, tool-jobs, api-job-controller	-	Producers (background bash/pwsh and PTY sends) register running work; record-declaring jobs additionally stream raw output for non-consuming observers; tool-jobs is the model-facing controller that reads, lists, and kills it; jobs-local is the process-local registry.
ctx.web	seam	web	web-search-deepseek, web-deepseek-api, web-fetch-http	tool-web	-	Search and fetch providers register into one ctx.web seam; tool-web owns the stable model-facing names.
ctx.spillStore	seam	spill	spill-local	spill-policy	-	The backend saves oversized tool text and returns a model-facing locator plus retrieval hint; spill-policy is the tools/post-execute consumer that decides when to spill.
ctx.directoryPicker	seam	host-directory-picker	host-directory-picker-native, host-directory-picker-browse	api-workspace-controller	-	Discriminated interaction capability: the native backend opens one OS chooser on the host display, the browse backend serves listing/creation primitives for the in-app browser; dual-face backends fill ui-workspace directory-flow slots from their browser halves (no wire advertisement).
ctx.webServer	core	host-webserver	-	client-connection, client-modules, client-hmr	-	Plain node:http carrier: named-route registry, index transform taps, and the static dist fallback; web-transport plugins register their own routes.
ctx.webApp	core	web-app	-	harness-dev-context	-	The web-runtime row advertises one URL for its Web GUI: the configured publicUrl, otherwise the listener origin; DSH_WEB_URL, the startup URL, and harness-dev-context read the same value.
ctx.clientModules	core	client-modules	-	client-hmr	-	Composes the DSH_BOOT entry graph from an incremental dsh.client scan, serves plugin bundles, and notifies rebuilt/graph-changed subscribers.
ctx.workflowEngine	seam	workflow	workflow-ptc	tool-workflow, tool-ralph	-	One engine per context, as in bash, with no named-provider registry; the general workflow and fixed Ralph consumers start runs whose agent() calls fan out through ctx.subagents.
ctx.webhookRuntime	core	webhook	-	webhook-github	-	Provider adapters dispatch authenticated deliveries; trusted plugins register independent process-local rules, and the runtime turns non-null results into ordinary Workspace-backed Sessions without delivery or completion state.
ctx.lsp	seam	lsp	lsp-stdio	tool-lsp	-	Provider registration and selection plus normalized query execution over exactly four operations; the seam offers no protocol escape hatch, so a backend translates into the normalized request and result.
ctx.dynamicCordisRunner	core	cordis-host-runner	-	tool-cordis	-	Owns the in-memory definition registry, the vm sandbox for host halves, and the request-run round trip; browser pages reach the same service over the wire through its remote namespace.
ctx.cordisInspect	core	cordis-host-runner	-	tool-cordis	-	Registers host inspect providers, mirrors the client provider manifest, and routes client queries through the dynamic Cordis transport.
ctx.liveshareShares	service	experimental-liveshare	-	-	-	Publishes the owner share-management operations as one Typert Remote namespace that the owner client face calls; every method delegates to the same operations the same-origin routes used.

Maintenance mode: hybrid: services are discovered from Cordis declarations; interface/implementation/consumer roles are classified in scripts/gen-doc-graphs.ts with a completeness guard.