Files
deepseek-harness/docs/capability-seams.zh.md
T
Xu Hanxiang 635d9c88f6 feat(liveshare): add the host, viewer, and client share surfaces (#6749)
* feat(liveshare): add the owner host, viewer host, and share runtime

The owner-side half of the bundle: the share host that publishes a Session to a Relay and answers one viewer per share, the owner credential/authorization records, the fork registry and its enforcement, the read-only viewer access policy and read budgets, the turn-requester fold, and the Relay gateway worker. The viewer host renders the served page's assets and declarations; no browser code is included in this layer.

* test(liveshare): cover the owner host, viewer host, and gateway

Keyless host-side coverage: share publication and restore, owner login/authority, fork registry and enforcement, viewer read policy and budgets, the turn-requester fold, the Relay tunnel worker and gateway commands, and the served viewer page. The browser surfaces are covered by the client layer's own suite.

* chore(build): register the host bundle in the compiler, dependency policy, and CI

The package manifest, Host compiler face, and tsdown host entries the bundle needs; the workspace constraints the built gateway/declaration artifacts require; the release-family and README model-experience rows; the coverage-lane exemption; and the keyless CI job that runs the share cases on Linux. The dependency-policy classifications wait for the client layer, which is where the package's client face (and its imports) first appears.

* docs(liveshare): record the bundle's subsystem, projection, and decision rationale

The package README for the host layer, the subsystem page, the persistence record that declares the viewer principal projection, and the note that keeps the protocol and owner-surface decisions with their evidence.

* feat(boot): offer the Liveshare host bundle in the CLI profile and plugin manager

The bundle joins the optional bundles the CLI installation carries and the Official group the plugin manager lists, so an owner can switch it on without editing a profile by hand. The plugin-manager and plugin-config expectations follow in the client layer that renders the card's browser half.

* chore(docs): regenerate the graphs, catalogs, and persistence records for the host

Run the generators over the host layer: the event producer/consumer graphs, the persistence catalog and schema inventory, the config catalog, the module graph, and the Cordis API catalog. The persisted viewer-principal event appears in the catalog and the historical format index counts it.

* fix(liveshare): keep the bundle's locale display metadata in this layer

The CLI profile registers the bundle as optional, so the plugin manager reads title and description from ./locale/*.json. Ship the two locale files and their export here; the browser half is not needed for display metadata.

* refactor(liveshare): read the turn boundary through the typed Agents service

The retained projection-handle migration left two assertions converted through unknown; ctx.get('agents') already exposes turnBoundaryOf, so the host and the cancel-admission case call it directly and the unknown-cast baseline stays untouched.

* test(liveshare): expect the canonical viewer tier from the three-mode harness

The Relay reports a share published with the withdrawn fork-readonly tier as view and carries the fork grant separately, so the harness compares the canonical tier and forwards an explicit allowsFork when the case names one.

* refactor(liveshare): share the reader-facing record and body readers

The fork decision and the access snapshot built the same share facts twice, and the two share-writing routes read the same share-naming JSON body twice; both pairs are now one helper each, so jscpd no longer reports them. Behavior is unchanged.

* test(web): record the host layer's optional-bundle expectations

Registering the LiveShare bundle in the Official group adds its card and description to the plugin manager and plugin-config pages, and the packed preview must state that its host plugin needs LIVESHARE_RELAY_URL instead of a generic applied toggle. Refresh the affected goldens locally (keyless web snapshot refresh) and keep the card badge at this layer: the client list that labels it experimental arrives with the client layer.

* docs(liveshare): mark the shipping owner policy note implemented

The protocol-and-owner-surfaces decision shipped with this bundle, so the note moves from proposed/ to implemented/ in both languages, its proposal-era headings become Decision/Verification/Consequences, and the subsystem page plus package README link to the new path. The pairing record moves with the triplet.

* fix(liveshare): judge tool turns from the open Session turn and recheck the narrowed write

The master baseline has no ToolExecutionInput.turn, so the host derives the turn a tool execution serves from the Agent's Session: the latest turn/start with no turn/end after it. A missing Agent, Session, or open turn yields no turn and the fork guard refuses the execution (fail-closed) instead of reading it as the owner's. Also refuse a fork that names a child without a bound rpcId/operationId, classify forwarded paths by their normalized pathname so /api/session/./fork or a query suffix cannot skip the fork decision, and ask the write gate again after the final authorization refresh so a share narrowed to view during fs/write-intent cannot write. The subsystem page, package README, and model-experience census follow the two-tier model and the bounded-write child ceiling.

* refactor(liveshare): read the open turn beside the requester fold

The derivation reads the same Session log the requester fold decides, so it
lives with that fold and the host imports it instead of keeping a private copy.

* test(liveshare): cover the derived turn and the refusal paths

Drive the host's real derivation from Session events: the open turn of the
Agent's Session decides a viewer turn is confined and an owner turn is not,
while a missing Agent, an absent open turn, and a requester the host no longer
drives all refuse instead of being read as the owner's. Cover the three safety
behaviours the host commit added: fork child naming without a bound request
identity, dot-segment/query fork paths that must still reach the fork decision,
and a share narrowed to view while fs/write-intent awaits.

* fix(liveshare): avoid the deprecated snapshot reader and the extra casts

The host derived the open turn by scanning the Session event log, which the
deprecation note forbids for new production calls. Read the same state from the
turnBoundary projection the Agents service maintains instead, and let a spec
supply a fixture boundary reader where production supplies turnBoundaryOf.
The live attribution of an execution is unchanged: an absent boundary or one
between turns still yields no turn and the guard refuses it fail-closed.

* docs(liveshare): describe the bundle's indirect model experience

The bundle's Model Experience moved to the audited indirect classification,
so the README sentence now names the path: viewer prompts the owner host
forwards into a shared Session drive that Session's model requests. The
KV-cache paragraph and the bilingual pairing record follow.

* test(liveshare): pin the turn-start admission for steered and admitted reader input

The pre-step admission already re-reads Relay authority from each entering message's own source and refuses queued reader input whose grant ended before the model runs; the new cases pin the steer path and the admitted viewer turn, so the turn-start half stays proven next to the delivery-time recheck the Session Controller owns.

* test(liveshare): adapt the replay and cancel expectations to the parsed tier

* test(liveshare): align the access-state expectations with protocol v2

The parsed share-access-state frame always carries allowsFileUpload, the
withdrawn fork-readonly word no longer implies a view tier or forking, and a
hand-built frame may not name it. Update the hand-built expectations and the
two fixture specs that named the retired word, without touching production
semantics.

* test(liveshare): record the in-flight cancel race after the controller revert

The Session Controller no longer re-reads a caller's access before cancelling,
so a cancel admitted before the reader's grant ends keeps its effect. State that
as the known limitation the earlier refusal tests documented instead.

* feat(liveshare): add the viewer attachment-upload switch

The share record, registration handshake, access-state replay, and share-viewer
policy carry an owner switch that is off by default: it admits fileUploads/upload
on the shared Session and the viewer's own forks, is independent of the tier and
of forking, and is normalized to off at every untrusted state-file or frame
boundary.

* docs(liveshare): state the sandbox tiers and the attachment switch

Name the two execution tiers as a read-only sandbox and a bounded writable
sandbox, and document the independent default-off switch that lets admitted
viewers upload attachments, including that legacy shares read as off.

* refactor(liveshare): drop the withdrawn fork-readonly migration

The feature never shipped, so no stored record can name the withdrawn tier and
the boundary needs no compatibility path. Read a stored fork switch as exactly
what it states, let an old Relay state the switch explicitly instead of
inferring it from the tier, and stop accepting the retired mode name on create
or restore.

* fix(liveshare): preflight a resumed child's limit before publishing it

A resumed child is announced through agent/created before its execution limit
installs, so an installability failure left a created Session whose guard never
landed. Resolve the recorded child's granted workspace before activation and
refuse the resume there, so a child this host cannot confine is never published.

* refactor(liveshare): render the viewer page through the reader's own Peer

The served-page seam now hands the frontend reader the reader's Peer, which renders that page's own
opening access rows; the Liveshare side no longer assembles a global access snapshot and the removed
global is gone. The viewer read service builds the same Peer it already creates for every dispatch and
passes it to the asset reader.

* fix(liveshare): keep the owner upload switch across an older Relay's access frame

The Relay is the authority for what a viewer receives, but only for the fields its frame states. An
older Relay predates the upload switch and omits it entirely; the protocol parser rightly normalizes a
missing switch to off for frames that state it, so the host must inspect the raw answer to tell not

* test(liveshare): adapt the host specs to the current tool and session APIs

The host specs drove a single tool through the pre-batch executor shape and handed
some tests a Session outside its store; the current tool executor takes a call batch
and Session appends require the owning SessionStore. This adapts those fixtures to
the current shapes without changing what each test asserts.

Also gives the reader's own fork the same Session permissions as the source grant:
forking its own child again and renaming it are allowed on the child only, while the
source Session still refuses renaming and keeps forking as its one Session verb.

* fix(liveshare): let the owner's background turns run while a share is served

The requester fold only counts a message with `source.kind === 'user'`, so a
turn a background event opened has no attributable input and stayed `unknown`;
the source-session tool guard refused every tool in that turn. Establish the
owner's own turn for an input-less turn and leave unattributable input unknown.

* fix(liveshare): grant the reader its own fork's rename and gate child forks by the fork switch

* refactor(liveshare): read the served page through webServer.readResource

* feat(boot): offer the Liveshare host bundle from the official bundle list

`@deepseek-ai/dsh-official-bundles` owns the shipped template, retired, and
optional bundle lists now, so the liveshare bundle joins `OPTIONAL_BUNDLES`
there instead of being restated in the app-boot profile module.

* feat(liveshare): gate the reader's own fork independently of its input permissions

The reader's child gets prompt, cancel, and rename from a role with no extra
condition, while forking the shared Session or one of the reader's own forks
belongs to a separate role bound to the owner's fork switch. A viewer cannot
rename the shared Session, and a withdrawn fork switch also withdraws forking
a child.

* test(liveshare): adapt the admission specs to the current tool and driver APIs

* feat(liveshare): accept only the declarations a plugin's own package owns

A viewer plugin may contribute endpoints a share can offer, so a declaration
has to name a live Host Remote endpoint whose generated id belongs to the
declaring package. Fail closed: no loader entry, no local endpoint, no owning
package, or a foreign owner all refuse the declaration, and the recorded
attribution is the package name the owner sees.

The package's Typert artifact registers after its apply runs, so a plugin
declares once that registration has happened.

* feat(liveshare): classify every Remote endpoint before the reader policy decides it

The share-viewer policy refuses by default, so the endpoints it decides were a
handwritten whitelist that could drift from the generated endpoint set. State
every endpoint's reason in one shared table: the Client face proves it covers
`RemoteEndpoint` (both directions), the Host derives `POLICY_DECIDED_ACTIONS`
from the reader entries, and a load-time assertion fails if the derived set and
the roles' actions disagree.

* fix(liveshare): declare the Client face its classification gate compiles in

Typert attributes a package's exports to a face only for manifests declaring
`dsh.client` plus a `./client` subpath (`isDualFacePackage`). Without that row
the client catalog read `exports["."]` — the Host entry — from the Client
program, which holds only the classification table and its completeness gate,
and failed on the source that program does not contain.

Export the gate module as `./client`, declare the Client row, publish its
bundle, and exempt the package from Client/Host dependency treatment: the
runtime importing these dependencies is the Host's, and `dsh.client` here only
attributes the compilation face.

* test(liveshare): align worker fixtures with the protocol tenant contract

The protocol layer rejects a share RPC actor whose tenant is empty at the IPC ingress. The worker fixtures still described a peer normalizing the tenant to an empty string, so the Host dropped every fabricated request event and the lifecycle and correlation polls timed out. Use a concrete tenant in the fixtures; those scenarios do not depend on an empty tenant.

* chore(docs): count the liveshare persistence nodes in the format index

The regenerated current-checkout catalog adds the liveshare viewer-principal nodes, so the v4 row's node count moves from 622 to 626. Refresh the generated format index rather than keeping the pre-liveshare count.

* refactor(liveshare): consume the protocol package's single public entry

The protocol layer now publishes only its root entry, so the Host face reads the wire codecs, identity contract, and viewer-state vocabulary from the package root instead of the removed /protocol and /identity subpaths.

* fix(liveshare): classify the schedule cleanup endpoint before the Client gate reads it

The Client completeness gate compiles against the generated Remote endpoint map; master added schedule/deleteInactive after the table was last filled. It mutates the owner's schedules like its neighbours, so it stays owner-only.

* chore(release): carry the liveshare package to the rc.3 family version

* docs(liveshare): align the host docs with the shipped two-tier shares

The subsystem page still described a withdrawn fork-readonly compatibility, a
write-only source drive, and an immutable execution.turn. State the two tiers,
the independent fork and upload switches, the refused unknown mode, and the
turn derived from the Session boundary. Mirror the Chinese pages and re-record
the pairing hashes.

* fix(liveshare): describe the writable tier in the plugin card

The package description, both locale descriptions, and the three Web goldens
still told the owner that sharing is read-only. State driving, bounded writes,
forking, and the independent upload switch instead.

* chore(liveshare): forward the owner credential file from the bundle patch

The README lists LIVESHARE_OWNER_CREDENTIAL_FILE beside the other owner
settings, but the patch left it to a direct process.env read. Pass it through
the same config field as its siblings.

* docs(liveshare): drop stale fork module comments

The registry header still said read-only forks only, and both the registry
and the policy carried an orphan JSDoc block in front of the real one.

* refactor(liveshare): drop unreachable fork tool effect fields

ForkToolRequest.writesWorkspace and changesConfiguration had no producer in
the repository: the guard never sets them, and the only callers were the
tests. The write-denying branch also contradicted WRITE_FORK_CEILING, which
admits the bounded write tool. Remove the fields, their refusal codes, and
the test cases that manufactured them.

* refactor(liveshare-protocol): retire the attachment-upload capability

Sharing itself now carries attachment upload, so the protocol no longer
states an independent switch: `LIVESHARE_CAPABILITIES` drops
`file-upload`, and share specs and access-state frames drop
`allowsFileUpload`. Wire frames stay v1 and no Relay is deployed, so no
compatibility layer is needed.

* refactor(liveshare): grant attachment upload with visibility

The owner controls sharing, audience, the tier, and forking only.
`fileUploads/upload` now rides the Session read role, so every Session a
share serves the viewer accepts files, independent of the tier and the
fork switch. The owner record, the share APIs, the registration handshake,
and access-state adoption no longer carry an upload switch; an older owner
state file that still contains the field loads with it ignored.

Accepted risk, recorded in Known Limitations: an owner cannot refuse
uploads for an admitted viewer.

* feat(liveshare): share the owner wire records

Move the owner identity report into a module both compiler faces can import, and
declare the share-management request, result, audit, and capability records there
with the same fields the same-origin routes already answer. The Remote failure
vocabulary joins the same module so a client learns the liveshareShares/ codes
without importing the Host.

* refactor(liveshare): extract the owner share operations

Move the twelve share-management handler bodies out of the route closures into
operations implemented once inside apply(), leaving each HTTP route with its JSON
parsing, normalization, and legacy status/body. Each operation documents the
side-effect order it keeps and what reordering would break.

* feat(liveshare): serve share management over Typert Remote

Register a LiveshareShares Remote service over the same operations the routes
call, publish its ./typert and ./remote artifacts plus the shared ./types module,
and make the shared records part of the Client compiler face. The owner page gains
the Remote endpoints while the HTTP routes stay as thin adapters.

* chore(docs): regenerate the Cordis catalog for share management

Record the liveshareShares service on the LiveShare subsystem page, link its
wire records to that page, and regenerate the runtime API catalog. The service
declaration moves to the package entry so the host-face catalog projection can
render it.

* test(liveshare): refuse share management to viewer Peers over Remote

Cover the owner Peer's Remote list and the share-viewer denial of list, create,
stop, and setRelay. The refused calls leave the share list empty, the selected
Relay unchanged, and the worker channel without an add-share.

* chore(liveshare): mark the typert resource follow-ups behind #7003

The share-management Remote ships against today's resource registration. Default
resource resolvers and the stricter identity rules arrive with #7003, so the two
places that will change carry a TODO naming the PR.

* fix(docs): classify the liveshareShares service role

The share-management Remote adds one owner-side service, so the capability
seams graph owed it a role row; without the classification the generator
refuses to render and doc-sync fails.

* fix(liveshare): complete the bundle metadata and restore the static gates

The bundle shipped only two of the eight shipped-language metadata files, and its
browser face had no named tsdown config, so the locale metadata gate and the
browser bundle walk both failed. Ship the full locale set and name the client
build; share one owner-body registrar between the two POST adapters so jscpd
stops reporting an eight-line clone.

* fix(liveshare): give the bundle a client source route and a typed peer double

The product-use walk follows `${name}/client` for every mounted bundle, so the
package needs the source mapping and a Client entry the mapping resolves to.
Replace the unknown-cast peer double with a complete PeerScope literal.

* test(liveshare): adapt the viewer admission rows to the Session default resolver

#7003 replaced the `session/page` and `session/follow` resource readers with the
Session kind's default resolver. A body carrying both `sessionId` and `address`
is now refused as invalid resources before the share policy reads either, while
a lone hidden `sessionId` still resolves and is refused by the policy.

Records the new expectations; the served page names one identity per request.

* feat(liveshare): resolve create's request Session through the default resolver

#7003 registers the `session` kind's default resolver with the Session
Controller, and `liveshareShares/create` names its Session in the one request
object, so the Gateway resolves that Session for a non-owner Peer without a
reader declared on the method. The owner Peer reaches the operation without
an access decision.

Adds the Gateway resource assertion and the owner-path assertion to the
share-management security spec, regenerating the Cordis catalog.

* test(liveshare): refuse a viewer body naming two Session identities

A prompt or cancel body carrying both `sessionId` and `address` reaches the
Gateway, whose Session resolver refuses it as invalid resources, so the target
child operation never runs and no request content comes back. Prompt and
cancel requests name their Session by `sessionId` alone.

* test(liveshare): widen the two-identity coverage across the reader endpoints

The resolver refuses a request that names two Session identities for every
namespace, so cover the remaining reader endpoints with one parametrized case
instead of leaving them to the generic Gateway tests.

* refactor(liveshare): remove the unreferenced gateway heartbeat policy

The production worker keeps its own interval and missed-pong counter, so
nothing imported this module; only its spec did.

* refactor(liveshare): extract the owner state persistence

The state file reader, writer, serialized write queue, and stored-share
record types move out of the host plugin unchanged.

* refactor(liveshare): extract the Relay authority reader

The access-state cache, its generation fence, the admission rule, and the
authoritative read that adopts a frame move behind one factory.

* refactor(liveshare): extract the tunnel worker supervision

Worker start, settlement, registration replay, expiry timers, owed Relay
rows, and the credential state each registration presents move out of the
host plugin behind one factory.

* refactor(liveshare): extract the owner share operations

The twelve operations keep their order and side effects but move behind an
explicit deps factory, so the host plugin mounts them instead of owning
their bodies.

* refactor(liveshare): extract the owner routes and source access

The sixteen owner HTTP routes, their request adapters, and the credential
store move behind registerOwnerHttpRoutes. The confined source Session
layer and its turn control move to source-access, which the share-host
re-exports for its public helpers.

* refactor(liveshare): split the viewer reader into dispatch, fork, and lifecycle

The request entry and endpoint handlers, fork orchestration and branch
facts, and the streams/calls/Peers lifecycle move out of viewer-read,
which keeps the deps types and assembly. Order, TOCTOU re-checks, and
Peer ownership are unchanged.

* refactor(liveshare): share the wire JSON helpers and the fork enforcement record

The split duplicated `json`/`isRecord` across the extracted owner modules and the
child enforcement options at three call sites; the stored ACL selection type also
lost its reference to the wire type. One helper module and one record factory keep
the split modules from carrying their own copies.

* refactor(liveshare): move the shared owner record and one-definition helpers

The split published OwnerShare from the assembly while every extracted module
imported it back, and left each host module carrying its own isRecord. Move the
share record and its ACL summary to a neutral module, name the two optional
service seams instead of inline casts, and import one wire JSON helper.

* refactor(liveshare): remove the fork-enforcement audit event

Nothing consumes `liveshare/fork-enforcement` except the spec that watched
it, so the minimal-surface rule drops the declaration, the reporter, and
every report call instead of reserving an extension point for later.

The wiring spec now asserts the outcomes an observer could previously
infer stages from: an install that returns nothing leaves
`ForkRegistry.enforcementInstalled` false and the child's prompt gate
refused with `fork-ceiling-uninstalled`. The subsystem prose no longer
names the removed refusal code, and the Cordis/doc catalogs are
regenerated.

* fix(liveshare): surface fork enforcement failures

Three registration paths swallowed the error behind a fail-closed
refusal. Keep refusing, but carry the reason:

- `preflightForkChild` now throws `fork <id> preflight failed: <message>`
  when the stored child cannot be read, instead of returning and letting
  activation fail later; `share-host`'s `prepareChild` caller already
  propagates that through the viewer's `fork-prepare-failed` answer.
- A child's confined `read`/`write` registration keeps its error in a
  `ForkEnforcementFailure`, so `prepareChild` throws
  `fork execution limits are unavailable: <message>` with the error as
  the cause instead of the bare message.
- Source-session access keeps the refused registration on the
  installation and logs it beside the existing confinement refusal.

The wiring spec asserts the preflight failure and both captured errors.

* refactor(liveshare): move the client placeholder face out of this layer

The `./client` entry existed only so the package's Client face could
compile the viewer endpoint classification against the generated Remote
map; it published no runtime this product used. P3b owns the real Client
face, so P3a drops the placeholder instead of shipping a surface ahead of
its consumer:

- delete `src/client/*` and the package's Client tsconfig; the endpoint
  spec keeps the Host-table diagnostics, and the Host still derives the
  policy action set from that table
- drop `dsh.client`, `exports["./client"]`, the `lib/client.js` publish
  entry, the browser tsdown build, and the package path alias
- remove the dependency-policy exemption and the devDependencies only
  those client sources imported
- the Host tsdown face still skips the Client build pass; `./typert` and
  `./remote` stay Host-generated and the Client tsconfig never fed them
- README and subsystem prose no longer claim a browser face

* chore(ci): drop the stacked-PR e2e dispatch input

The narrow dispatch scope existed only to verify a stack's exact SHA while its
ordinary pull-request checks were unavailable; it is not part of LiveShare and
never belonged in this layer's diff.

* feat(liveshare): add the share dialogs, viewer seats, and client surfaces

The browser half of the bundle: the owner's share dialog and management surfaces, the owner sign-in flow, the viewer page's session plugin, brand, status, and seat components, and the read-only permission and model seats that replace the shipped composer controls at a shadow rank. The package README regains the client implementation links this layer provides.

* test(liveshare): cover the client surfaces and viewer seats

jsdom coverage for the share dialogs, owner login and identity, the viewer page composition, the read-only seats and their shadow rank, the served-page artifacts, and the client-face registration. The host-side suite stays in the lower layer.

* chore(build): ship the Liveshare client bundle

The client compiler face and solution reference, the tsdown client entry beside the host phase, the manifest's client export, client runtime files, locale assets, and client dependencies; the dependency-policy classifications whose consumers appear with the client face; the generated client slot catalog; and the plugin-manager expectations that list the bundle's card.

* fix(liveshare): shadow the shipped brand seats instead of colliding with them

sidebar.brand.mark and sidebar.brand.name are single slots, and a served viewer page mounts the owner's plugins, so on an official build ui-brand-official already registers both at the default rank. Register the viewer entries at a shadow rank and pin the collision in a registration spec, as the composer seats already do.

* fix(liveshare): clear the viewer's composer blocks when its plugin is disposed

The honest-composer effect raised a per-Session block but its disposer only unsubscribed, so a disposed or replaced viewer page left the owner's composer blocked. Track the Sessions it addressed and clear their blocks on disposal; a spec pins the recovery.

* style(liveshare): drop unnecessary type assertions in the registration specs

The slot test runtime's renderSlot already accepts these owner props, so the contracts-ready lint reports the as-never assertions as unnecessary.

* test(web): mark the client layer's LiveShare card experimental

The client layer ships the card that renders the bundle, and the recorded goldens already carry its Experimental badge. Add the bundle to the manager's always-held extension list and to the presentation's experimental set, and expect badge 1 in the plugin-manager spec.

* fix(liveshare-client): return to the share after viewer sign-in

The viewer page names its share in its own query (?shareId=...), so a
sign-in that returned to the bare path brought the reader back to a page
that no longer named their share. Build the Relay sign-in entry from the
page's path and query, and keep the entry's construction in one testable
function.

* fix(liveshare-client): state a half-saved share permission accurately

Saving the share permission writes the session tier first and the plugin
endpoint selection second. When the second write was refused the dialog
claimed the whole save had failed, though the tier and fork switch were
already stored. State which half landed, and re-read the host's record so
the fields show what it kept while the refused endpoint pick stays for the
retry.

* fix(liveshare-client): route viewer copy through the client locale seat

The viewer surfaces translated their own copy from navigator.language, so
a language chosen in Settings could not reach them and a Node boot read the
machine's language instead of the page's. Register the package dictionaries
once, as the client face already does, and take the bound translate seat:
React seats get it from their locale registration, and the plain-DOM status
banner takes it from the plugin and repaints on locale changes.

Also move the viewer status banner's copy and reason helpers to that seat,
and update the viewer specs to provide a LocaleRuntime the way the assembled
viewer page does.

* test(liveshare): assert the two-tier fork ceiling in the viewer artifact

The branched row states the ceiling the host installed: a view-tier
(fork-readonly reads as view) share's child runs under the read-only fork
ceiling, while a write-tier share's child carries the bounded write
ceiling, whose host half readonly-fork-cold-child.spec.ts covers. Read
that statement through the shipped Tooltip's pointer events: after the
rebase it listens to pointerenter/pointerleave, so the previous mouse-event
hover never raised the bubble and the row's statement stayed unread.

* feat(plugins): hide LiveShare until its plugin rows run

A default installation ships the LiveShare package but composes none of
its plugins, so the plugin manager must list it nowhere; enabling it
through the profile's cordis.patch.yml or its bundle selection starts
those rows and only then shows the card under Experimental plugins.

The visibility rule reads the bundle rows' own run state rather than the
profile's bundle selection, because a row inserted through cordis.patch.yml
runs while the bundle stays unselected. The hidden bundle ID stays
addressable, so openBundle still opens its details.

* test(web): assert the hidden LiveShare card across both lists

The plugin-manager scenario now checks that the default profile lists no
LiveShare card in the Experimental plugins group or on the More page, and
that the offered count is one lower than the shipped optional bundles. A
dedicated scaffold writes the bundle's declarations row into the profile
patch, waits for the loader to recompose it with bounded timeouts, and
checks the card joins the list and leaves it again when the row is removed.

* docs(plugins): document LiveShare's default hidden state and enablement

The package README now states that a default installation shows LiveShare
in neither plugin list, and gives both enable routes: inserting the
bundle's two entries in the profile's cordis.patch.yml (placeholders for
the deployment's Relay identity values, with the recomposition caveat), or
selecting the bundle in dsh.profile.bundles. It also states that removing
or disabling the rows takes the card away again. The subsystem page keeps
the rule and links to the README for the exact entries, and the plugin
manager README describes the hidden-until-running list behavior.

This also repairs the README's pre-existing Model Experience mismatch with
its audited indirect classification, which failed the documentation gate
before this change.

* docs(agent-notes): record LiveShare's hidden-until-running rule

Record why the plugin manager keys visibility on the bundle rows' run state
rather than the profile's bundle selection (the cordis.patch.yml route
leaves the bundle unselected while its plugins run), and why the detail
entry by bundle ID survives the hidden card. The rejected alternatives and
the costs of the decision are stated for review.

* test(web): expect the hidden LiveShare card in the configuration scenario

The configuration-page scenario reads the same More list as the plugin
manager, so its offered count is one lower than the installed optional
bundles while LiveShare's declared rows do not run.

* test(web): re-record the plugin goldens without the default LiveShare card

Refresh goldens remove the LiveShare entry from the Experimental plugins
list of both plugin-manager snapshots and from the plugin-configuration
snapshot, and drop the refresh card count from 12 to 11. Re-analysis under
replay confirms both scenarios green.

* fix(liveshare-client): release the viewer page state with its plugin

The viewer context facts, capability, and status stores are module-level so
every viewer surface reads one page's answer, but nothing released them when
the plugin owning the page was disposed or HMR-replaced, so the next mount
inherited the previous page's share facts, tier, and status. The viewer
session plugin now owns that lifetime: it clears the stores when it mounts
and disposes, and advances the read generation so a previous page's in-flight
answer cannot publish into the new page. A spec pins the disposed page and
the inherited state.

* feat(liveshare-client): add the viewer attachment-upload switch

The share carries whether viewers may upload attachments as its own switch,
off by default and independent of the session tier and the fork switch: a
view-tier share may allow uploads and a writable one may refuse them. The
share dialog sets it in both the create and edit flows and submits it with
the permission write; the manager sets it per share beside the fork switch.
A share the Host does not report reads as off. The dialog also states the
tier as the sandbox it runs in, so neither tier is described as carrying
file uploads.

* docs(liveshare): describe the sandbox tiers and the upload switch

The host layer owns the package README statement of the two tier sandboxes
and the upload switch; this layer's documentation adds the subsystem
contract for the switch and the client README's attachment-intake sentence —
file intake follows fileUploads/upload, which a share grants only while its
own switch is on.

* refactor(liveshare-client): drive the owner dialogs through the modal layer and shared primitives

Both owner dialogs ran their own focus trap beside Modal's layer, so initial focus, Tab wrapping, Escape
and focus restoration were each installed twice and could disagree. The hand-written trap is removed;
the shared layer owns the keyboard lifetime, including the dialog's own restore target. The hand-written
returns focus to the opener exactly as before.

The same surfaces also stop inventing their own controls: the session permission and the share lifetime
are SegmentedControl choices like the capability tier, and the independent fork and upload switches are
the shared Switch primitive. Stopping a published share now asks for the shared RiskConfirmation
acknowledgement before the destructive request runs.

* feat(liveshare-client): state the narrowed owner copy and correct the viewer surface

The share manager no longer promises a request-and-approval flow that the protocol dropped: its
description states the online state and access scope it actually shows. Stopping a share is now gated
on acknowledging that the published link stops working immediately.

The viewer status banner keeps its placement inline but takes its colors from the theme tokens with
system-color fallbacks, so the served page stays readable when the client stylesheet never loads. Both
owner dialogs size against the Modal padding box instead of a second viewport calculation, and a long
list title wraps instead of pushing the status out of its row.

A forked branch is stated as a branch, without claiming a read-only workspace the write tier does not
have; the same correction applies to a branch whose sandbox limits failed to install.

* fix(liveshare-client): align the viewer face with the current Client services

The rebased Client surface no longer carries uiConversation.noticeBranchRefusal: a refused branch leaves the view unchanged, so the viewer row consumes the rejection and the refusal-notice tests become containment tests. The plugin manager's bundle lists moved to dsh-official-bundles, so the liveshare bundle joins the centralized experimental and extension lists. Master's sidebar keeps the brand identity out of the accessibility tree when the page cannot start a Session, so the assembled-page test reads the viewer home link from the DOM. The roster gains the file-drag plugin ui-chat and ui-attachment now inject, and the fixture reads the protocol's Client-face carrier from its own project and brands the fabricated reasoning effort.

* refactor(liveshare-client): consume the protocol package's single public entry

The protocol layer now publishes only its root entry; the client tests read the wire and identity contracts from that root. The dependency policy keeps one liveshare entry carrying both the protocol vocabulary and the identity helpers.

* feat(plugin-manager): leave the LiveShare bundle unranked in the extension list

The bundle already stays invisible until one of its patch rows runs, which
keeps ordinary users from encountering it. Removing its ranking entry means an
internal profile that enables it finds the card at the end of the experimental
list instead of pinned to the front; the Experimental badge and the hidden-
until-running card both stay.

* refactor(liveshare-client): drop the attachment-upload switch

The share dialog and share management present only the tier and the fork
switch; attachment upload follows visibility on the Host, so there is
nothing left to toggle. Removes the field from the client share record,
both locale seats, and the dialog tests, and states the new rule in the
viewer README.

* feat(liveshare-client): drive share management through the liveshareShares Remote

The owner dialogs stop posting the twelve management routes and call the
generated namespace instead. The share list, creation, stopping, permission and
endpoint writes, the Relay read and override, the owner identity read, the
audit, and both Relay checks resolve to a RemoteResult, so a refusal is read
from its `liveshareShares/` code instead of an HTTP status. The sign-in round
trip keeps its three same-origin routes.

The package's client entry mounts its own generated contribution and passes the
namespace to the share surfaces through the slot inject face. `dsh.client.inject`
now names `@deepseek-ai/dsh-api-remotes`, and the viewer endpoint table
classifies the twelve management endpoints as owner-only so the Client
completeness gate stays total.

Client specs substitute the namespace with a scripted double instead of stubbing
`fetch`; the assertions read the recorded requests.

* test(liveshare): drive the owner host cases through the Remote service

The host cases no longer register a route map and post JSON to it. They call
`ctx.liveshareShares` directly, which runs the same OwnerShareOperations the
remote Gateway dispatches, so each case keeps its side-effect coverage and
asserts the RemoteError code and details a refusal carries instead of a status
and body.

The ping case is gone with the route: the header action reads `relay()` for the
effective address, which the Relay-state cases already cover. The e2e harness
publishes through `liveshareShares/create` over the owner's own `/api` carrier,
and the sign-in/credential cases keep their same-origin routes.

* refactor(liveshare): remove the owner share-management HTTP routes

The twelve same-origin management routes are gone, together with the thin
adapter layer that existed only for them: the status/body error translation,
the per-route request-body readers, and the capability-selection parser. Every
side effect stays in OwnerShareOperations, which the `liveshareShares` Remote
dispatches.

The four remaining routes are the sign-in and credential ones:
ownerLoginStart, ownerLoginRedeem, ownerLoginCancel, and ownerCredential. The
route-registration case now asserts exactly those.

* docs(liveshare): describe share management as the liveshareShares Remote

The package README (both languages) and the subsystem page now state that the
share list, creation, stopping, permission and endpoint writes, Relay state,
identity, audit, and both Relay checks are `liveshareShares` methods, and that
the sign-in round trip and credential storage are the only same-origin HTTP
routes left. The owner source table points at share-operations.ts and
share-remote.ts for management.

Re-record the README pairing hashes and regenerate the Cordis surface sections,
including the inspect catalog's service description.

* test(liveshare): restore the Client classification gate

P3a dropped the Client-face completeness gate together with its placeholder
face. P3b owns the browser runtime, so the gate returns: the Client program
proves every generated Remote endpoint has a table row, and the spec pins the
compiled export beside the diagnostics the Host also uses.

* chore(build): restore the Liveshare Client compiler face

The rebase onto the Host layer lost the solution reference and the Host
exclude that kept `src/client` out of the Host program. The package now
carries a real browser runtime, so it takes the ordinary Client/Host
dependency treatment instead of the exemption its placeholder face needed.

* docs(liveshare): restore the package's client faces

The subsystem overview names the client faces again now that the browser face
is back, and the translation pairing record is re-recorded.

* test(liveshare): cover the browser surfaces and client readers

The browser half of the package now meets the per-file gate on its own
terms: the viewer request decoder, the share-type readers, the viewer
session selection, and the owner identity readers are pinned by direct
specs, and the seats, brand row, share-path chip, status banner, model
seat, and menu row gain the cases their uncovered branches named.

Two internal simplifications remove branches that no input can reach: the
brand row strips build metadata with one replace instead of a split whose
second operand was unreachable, and the viewer-session subscription no
longer starts behind a placeholder disposer that subscribe can never call.

* test(liveshare): cover the owner host and gateway glue

The host half gains the direct specs its uncovered branches named: the
stored credential file (absent, corrupt, unbound, empty facts, deletion),
the viewer principal comparison, the share Remote's audit delegation, the
registration handshake's plain-socket scheme, the relay refusal status
reader, the JSON body reader, the fork policy's mode helpers and empty
prefix, and the fork guard's unreachable-context refusal. The worker entry
is covered through a mocked worker module, so its boot decision runs
without a spawned process.

The served-page resource answer no longer carries a `string` body: both
call sites hand it bytes, and the string branch could not run.

* test(liveshare): cover owner state, authorization, and the header action

Pins the owner state file's restore and refusal rules against real files
(every optional fact, every invalid record, the owed Relay rows, and a
failed write), the authorization transaction's four bindings and its
single-use state, the declaration surface's stable package order and
repeated withdrawal, and the Session-header action that opens the share
dialog and switches it to management.

The owner state write chain no longer catches a rejection it cannot
observe: the map holds only promises whose failures were already absorbed.

* test(liveshare): close the owner and declaration surface gaps

Pins the authorization URL the browser opens and the production clock and
lifetime a transaction gets when the host passes neither, the declaration
surface's stable package order and repeated withdrawal, the owner state
file's restore and refusal rules against real files, and the Session-header
action's open, manage, and close paths.

The declaration disposer's two optional lookups are annotated instead of
tested: this effect registers each accepted name once, so its own disposer
cannot reach a missing entry, and the effect disposers are idempotent, so a
second withdrawal never re-enters that loop.

* test(liveshare): satisfy the lint and compiler gates in the new specs

The refusal double takes the empty details its code declares, the waits
return nothing instead of a void expression, and the IPC entry reads the
channel through a computed access so the lint rule does not read it as an
unbound method reference.

* test(liveshare): cover the gateway worker and tunnel supervision

* test(liveshare): cover the owner, relay, fork, and viewer host modules

* refactor(liveshare): keep the coverage hooks behavior-preserving

* test(liveshare): fix the typed listener and endpoint fixtures

* test(liveshare): cover the owner login, share manager, and viewer plugin

* test(liveshare): cover the share dialog and host fork wiring

* test(liveshare): satisfy the contract lint in the gateway worker spec

* chore(coverage): drop the liveshare lane exemption

* feat(liveshare): ship the remaining shipped-language dictionaries

The locale parity gate requires every shipped language beside each object-form
dictionary, so the Liveshare browser plugin now carries Japanese, Spanish,
French, German, Russian, and Brazilian Portuguese alongside `zh` and `en`, and
registers all eight.

Each dictionary is typed `Record<keyof typeof zh, string>` so a missing or extra
key fails the build, and named placeholders, slash commands, and API field names
stay verbatim in every language.

* docs(liveshare): document the host config and two exported host contracts

`verify-export-jsdoc` requires prose on every exported declaration: `Config`
states what a deployment sets and why `relayUrl` has no default,
`requestedBoundary` states how a fork request names its prefix and what an
unnamed one becomes, and `OpenStream` states what the reader tracks and when it
releases the stream.

* chore(docs): regenerate the liveshare catalogs and acknowledgement after rebasing

Rebasing the host layer onto current master left the generated artifacts at the
new base's state, because each conflict was resolved to master's side rather
than merged by hand. Recompute them from the rebased tree with the repository
generators: `gen-config-catalog`, `gen-doc-graphs`, `gen-persistence-catalog`,
`gen-client-catalog`, `gen-tool-catalog`, and `verify-persistence-formats
--write`. `gen-module-graph`, `gen-cordis-catalog`, and
`gen-official-bundle-catalog` computed no change.

The LiveShare persistence acknowledgement predated master's later changes to the
four user-message source roots and stored the inventory in a non-canonical
layout, so `verify-persistence-changes` could not read it. Re-record it with
`persistence-changes --update ... --decision same-version`, which chains it onto
master's current tips and rewrites the snapshot, the bilingual declaration, and
their pairing record. Re-record the ui-plugin-manager README pair, whose
LiveShare paragraph now matches on both sides.

* test(liveshare): read attachments by the complete image reference

Current master sends `session/attachment` the complete image reference the
conversation folded from the log and answers with the stored reference plus
bytes, instead of accepting a bare `attachmentId`. The viewer fixture still
read the old field, so every assembled-page image read failed and the
viewer-shell and viewer-global-privacy artifact tests timed out waiting for the
delivered image. Follow the new request field and keep verifying by id against
the Session's log.

* test(liveshare): pass the complete reference in the owner attachment probe

`session/attachment` now takes the complete image reference, so the admission
spec's owner-side probe sends the fixture's reference instead of a bare id.

* fix(liveshare): classify the current Client endpoints for the share-viewer policy

Master added session read/observation endpoints to the Client's Remote map, and
the share-viewer policy's reader role is the only grant they can receive. Name
the six read endpoints in the reader role and in the classification table, keep
the endpoints this Client assembly cannot name out of the table (they stay
owner-only by default), and extend the served-page contract plus an admission
test so a hidden Session is still refused.

* fix(liveshare): await and type the turn-requester projection

Register the fold before publishing the policy and source layer that read
it, surface a refused registration instead of leaving it unobserved,
reset the retained handle when the projection service reloads, and type
the boundary and execution reads from Agent and TurnBoundaryProjection.

* fix(liveshare): withdraw only the fork children a revocation saw

Apply a withdrawal to the entries the registry file holds when it
commits, leave a child recorded afterwards live across restarts, and
retry a failed withdrawal without replaying it over a newer child.

* fix(liveshare): refuse a fork that names no Session

Answer 400 with a named code before dispatch, so a malformed fork body
cannot reach the owner's Gateway unrecorded.

* fix(liveshare): stop injecting a child id into fork requests

SessionForkRequest mints the child id, so the injected field was ignored.
Forward the caller's envelope and rely on the recorded operation for a
retry; document the crash window that needs a caller-supplied child id.

* fix(liveshare): classify and dispatch one normalized path

Use the same pathname plus query for the endpoint decision and the owner
dispatch, and parse with URL.canParse instead of an empty catch.

* docs(liveshare): record the two-tier driving model

Rewrite the implemented note's stale tier, turn-carrier, upload, and
retry facts, add the superseding decision note, and keep the subsystem
page and package READMEs aligned.

* fix(liveshare): publish only the exported type module from lib/types

The package published every tsc-emitted lib/types/**/*.js file, so the client
JavaScript that imports .module.css files entered the tarball without those
stylesheets. Retain only lib/types/share-api-types.js, the one runtime file
the ./types export names, alongside the declaration tree.

Teach the publication allowlist that this package's emitted tree is completed
by its exact runtime file rather than the whole glob, and pin both the accepted
and rejected payloads.

* test(liveshare): mock the generated remote for assembled viewer pages

The assembled viewer specs load the client entry, which statically imports the
generated ./remote contribution. A clean checkout has no lib/ build, and Vite
resolves a static import while transforming the entry, before vi.mock can
answer it, so the jsdom suites failed to import the page roster.

Mock the contribution in each assembly spec, matching the owner-side face
tests, and provide a resolvable test stand-in whenever the artifact is absent.

* fix(liveshare): guard hover styles and draw the viewer banner hairline

Wrap the owner action, dialog actions, and viewer wordmark hover rules in
@media (hover: hover) so touch devices do not latch the hover treatment, and
draw the viewer status banner's neutral border at the 0.5px hairline width.

* refactor(liveshare): name the owner gateway directory

The owner-side Relay connection process is LiveShare's own gateway, not the
Host API gateway; move it to src/owner-gateway so the published entry
lib/owner-gateway/cli.js and the module headers say which gateway they mean.
The protocol vocabulary (frames, tunnel mode) keeps the word gateway.

* docs(liveshare): merge the tier and visibility notes into the owner note

* docs(liveshare): call the Relay the Liveshare server

* docs(liveshare): name the Liveshare server in the share-management JSDoc

* docs(liveshare): document that new shares are organization links

The shipped Share dialog sends neither accessMode nor allowedSubjectIds, so
every share it creates is open. The agent note, both package READMEs, and
CreateShareRequest's JSDoc now say that selected/approval shares are legacy
stored records that keep their ACL and access summary, that the UI has no
creation entry for them, and that the create fields remain for those records
and direct Remote callers.

* refactor(liveshare): drop the configurable owner display name

The reader-facing owner name now always resolves from the Relay-verified
credential: its display name, otherwise the subject label, otherwise the
Relay's host name. Config.ownerDisplayName and the namedOwner dependency
only fed the removed override, so delete both and the test configuration
that set the field.

* docs(liveshare): read the owner name only from the verified credential

Remove the LIVESHARE_OWNER_NAME row and its cordis patch mapping, and say
in both READMEs that a reader-facing share name comes from the
Relay-verified credential rather than local configuration. The
LIVESHARE_OWNER_DISPLAY_NAME legacy identity label stays.

* feat(liveshare): save the relay address from the share dialog

The public address is the owner's runtime choice, not deployment configuration:
the host loads without one, the dialog saves it into the owner state, and new
shares publish there until the owner saves another or clears it. A host with no
saved address contacts no server and its sharing surfaces state that.

* docs(liveshare): describe the address saved in the share dialog

The README, subsystem page, generated API reference, and their bilingual
pairing now state the dialog-owned address and the no-address host state.

* refactor(liveshare): sandbox a shared session instead of attributing turns

Retire per-turn origin isolation: delete the turn-requester fold, the
turn-boundary derivation, and every per-turn verdict, and make the source
access layer a session-level sandbox.

While any share over a Session is active the layer's guard permits only the
confined read it mounted (plus the bounded write when some share may write);
every turn of that Session, the owner's own included, runs through them and
nothing else. The layer is released once no active share is left, which
restores the Session's own tools, and the read-only layer is re-installed
when the last write share narrows to view. Each operation re-reads the
shares' current Relay grants and checks the resolved target against the
granted root.

A viewer's session/cancel now travels the standard Gateway dispatch under
the source-write role instead of a host-side ownership comparison, and a
share that stops, expires, or loses admission stops whatever turn its
Session is running.

Behavior changes:
- The owner is confined too: while a share is active the owner's own turns
  can only use the confined read (and bounded write), and the full tool set
  returns when every share stops or expires.
- Cancellation has no attribution: a viewer's stop cancels the shared
  Session's running turn, including one the owner started.

* test(liveshare): exercise the session sandbox and gateway cancel dispatch

Delete the specs that asserted per-turn attribution (turn-requester, source
cancel ownership, source execution turn, source turn revocation) and the test
fixtures only they used. Cover the behavior that replaced them: every turn of
a shared Session is confined while the layer is mounted, the layer is released
when no share is left, a write-to-view narrowing re-installs the read-only
layer, a share ending stops the running turn, and a viewer's cancel and prompt
both travel the standard Gateway dispatch as the reader's Peer.

The pre-step admission test now covers the messages' own principals, and the
projection double is gone with the projection it stood in for.

* docs(liveshare): document the session sandbox and retiring turn origin isolation

Update the package READMEs, the LiveShare subsystem, the share-viewer
principal persistence record, and the merged Agent Note: remove the
turn-requester fold, turn-boundary derivation, pinned source cancel, and
per-turn origin prose, and state the shipped facts instead — a Session-level
sandbox that also confines the owner while a share is active, a standard
Gateway cancel with no ownership comparison, and the pre-step admission check
as the principal's only consumer. Re-record the bilingual pairing records.

* refactor(liveshare): extract share dialog relay and identity hooks

Move the Relay address read/save/draft state and its connectivity and
permission checks into useShareRelayAddress, and the owner identity read
plus the one sign-in attempt into useOwnerIdentityLogin. ShareDialog
keeps the step guide and passes the identity facts saving an address
needs, so neither hook reaches into the other.

* refactor(liveshare): extract the share dialog create form

Move the session permission, fork switch, lifetime, and the create
action into useShareCreateForm and ShareCreateForm. The dialog keeps the
link, error, and created-record adoption it already owned, and the
shared choice builders live in share-options so the edit panel can use
the same session-mode list.

* refactor(liveshare): extract the share edit panel and tier picker

Move the stored share's permission, fork switch, endpoint tier, and the
one save into useShareEdit and ShareEditPanel, with the tier expansion and
summary in ShareCapabilitiesPicker. ShareDialog now composes the relay,
identity, create, and edit hooks and keeps only the link, advanced help,
and close/manage surface.

* fix(liveshare): take share dialog hook options as named parameters

The exported hooks documented an `options` parameter while destructuring it
in their signatures, so their JSDoc could not name the binding.

* chore(docs): regenerate graphs, catalogs, and pairing after rebasing on master

The rebase merged this branch's liveshare entries with master's forge entries;
the generated English sources and their bilingual pairing records now reflect
both.

* feat(liveshare): open the shared read and write tool surface

The source-session sandbox and each fork child's limit now admit one shared surface: read, read_image, glob, grep, present, todo_write, skill, web_search, and web_fetch at the view tier, plus edit and write at the write tier.

Every path a call declares is resolved and checked against the granted root before the deployment tool receives its canonical form; a pathless search uses the Session's working directory. Tools with no local file effect keep the deployment's own definition, which the guard vouches for by identity. Everything else, including bash, pwsh, cua, the plugin manager, and the schedule tools, stays refused.

* test(liveshare): cover the shared tool surface

Drive the view and write surfaces through the source sandbox and a fork child's limit: canonical paths, symlink and relative escapes, pathless searches, deliveries, the no-effect tools, both mutation tools, and every capability the surface does not name. Registration counts in the host wiring now read the shared table instead of one confined read.

* docs(liveshare): describe the shared tool surface

The package README, the subsystem reference, and the owner note now state the admitted tools per tier, how each declared path is checked, and that the no-effect tools keep the deployment's definition. Re-record the bilingual pairing and the generated event graph for the new fs/edit-intent consumer.

* feat(liveshare): confine viewer turns and admit PTC run_code

Owner turns of a shared Session keep the deployment's native tool chain. The
source layer now decides per turn, from the admitted input's share-viewer
principals, whether the turn is confined; agent/pre-step records that answer
in Host memory only, and the guard plus every confined replacement read it.
A turn the owner starts runs the deployment's tools unchanged, an owner's
steering input inside a viewer's turn stays confined, and stopping every
share still disposes the layer.

Both tiers also admit the PTC transport run_code. A non-empty
sandbox_permissions is refused; every nested tools.* call is a separate
execution through the same guard and confined replacements, so tools.bash
stays refused and read/edit/glob/grep keep their grantedRoot checks. Before
the runtime starts a program, run_code dispatches the new sandbox/policy
waterfall with the Session-resolved policy; the source layer caps it to the
share tier (read-only for view, workspace-write at most for write, never
danger-full-access) and drops the deployment's extra writable roots. A fork
child's installation applies the same cap from its live tier.

Verification: pnpm run typecheck, oxlint on the changed files, and the
focused liveshare specs for the turn marker, owner/viewer turns, run_code
admission and nested calls, and the policy caps. Local commits only; not
pushed.

* refactor(liveshare): drop the uncommitted-prefix fork state

The host never reads the source Session log, so it cannot know a completed
sequence. The forking command validates the requested boundary against its own
committed history instead, which makes the local boundary refusal unreachable.

* feat(ui-chat): export the official user renderer and shared-session copy

* feat(liveshare): mark shared-session reader messages through the chat node seat

* test(liveshare): cover shared-session attribution and the reused chat node seat

* fix(liveshare): leave steering rows to Chat

Only the message that opens a conversation carries the reader attribution;
steering is a turn-internal insertion, so its official Chat cell is untouched.
The wrapper now shadows the user cell alone.

* feat(plugin-manager): hide default bundles through their manifest

The LiveShare bundle now declares `dsh.bundle.listedByDefault: false` and the
page applies one manifest rule to every bundle: a default-hidden bundle is
listed only when the profile enables it, the installation carries it selected,
or one of its declared rows runs. The client-side name set and its special
details-by-id fallback are gone.

* docs(sandbox): document the per-program sandbox policy extension

The new `sandbox/policy` waterfall owns one event scope, the generated event
graph and subsystem reference now list it, and the catalog classifies its
payload type.

* chore(docs): regenerate the graphs and pairing after rebasing on master

The rebased branch now shares master's forge and sandbox service entries; the
generated English graphs and their Chinese counterparts are re-recorded.

* test(web): keep the plugin lists contiguous around the LiveShare card

The recorded accessible tree has no blank line between the last experimental
card and the installed-plugins heading.

* test(typert): expect the PTC sandbox policy event in the executor catalog

The new waterfall is part of the executor's model events.

* fix(liveshare): name the PTC transport without the unclassified tools export

The dependency policy does not classify @deepseek-ai/dsh-tools' RUN_CODE_NAME
as a safe host export. Liveshare now owns the reserved name locally, pinned to
the canonical constant by its test suite.

* fix(liveshare): close the coverage gaps in the owner-turn and PTC paths

The asynchronous policy resolver is covered by the executor tests; the
share-host guard covers unattributable executions and same-turn narrowing;
the owner's edit path exercises the native pass-through.

* test(web): align plugin goldens with the manifest visibility rule

The default profile no longer lists LiveShare before its rows run, the refresh
count includes the forge bundle master added, and the creation recommendation
skill catalog records the new bundle entry.

* fix(ptc): keep the disposed check lint-clean after policy resolution

The narrowed property read became an always-false conditional; the helper
method keeps the runtime check without the narrowing.

* test(liveshare): cover a relay probe stopped by host disposal

The probe checks the disposed flag after its fetch; a disposal landing during the
request now exercises that early return.

* fix(liveshare): encode identifiers without the base64url Buffer name

Packed worker deployments run a Buffer polyfill that only names standard
base64; the new helper produces the same unpadded base64url text from it. The
packed preview's generic bundle toggles skip the declaration-first Liveshare
bundle, which the ordinary Web scaffold covers.

* test(liveshare): build worker command fixtures from real file URLs

`file:///pkg/...` has no drive letter, so Windows `fileURLToPath` refuses it;
the launch-command test now derives both fixtures with pathToFileURL.

* feat(ui-chat): offer a user-origin seat above user rows

Chat now declares a session-scoped `conversation.chat.user.origin` list seat and passes the flow's renderer to the official user row through `ChatNodeOwnerProps.renderUserOrigin`. The flow supplies the callback only while the seat has an entry, and the official renderer calls it for `user` nodes alone, so steering keeps its DOM. Entries receive the durable message source and own their markup and copy; ui-chat ships none, and its shared-session dictionary entry moves back to the feature that writes it.

* feat(liveshare): attribute shared-session messages through Chat's origin seat

The client registers one `conversation.chat.user.origin` list entry on both faces instead of shadowing Chat's user node renderer. The component recognizes the durable share-viewer principal and states the Relay-asserted subject from the package's own `inputOrigin.sharedSession` copy in all eight dictionaries; owner-authored, malformed, and steering rows render nothing. The ui-chat runtime external and its client-inject edge are gone: the remaining ui-chat import is type-only, and `slots.inject` makes the registration independent of declaration order.

* chore(client): record the user-origin seat in the slot catalog

Regenerate the model-facing client slot catalog for `conversation.chat.user.origin`: the new list seat, its owner props, its declaring flow entry, and the Liveshare occupant. The subsystem slot tree follows the same declaration.

* chore(liveshare): publish the types entry as declarations only

`./types` no longer declares a runtime target into the tsc-emitted tree, so the
package no longer publishes `lib/types/share-api-types.js` and the workspace
constraint check no longer needs a package-name exception.

* docs(ui-chat): name the message-source decoration

The prose uses the exact field it decorates instead of the abstract term the
repository's concrete-terms gate rejects.

* fix(liveshare): classify master's tool-results stream after rebasing

Master added the `toolResults/watch` Remote endpoint and bumped the workspace to
0.2.1-rc.4; the viewer endpoint table and the read role now cover the stream,
and the package version follows the root.

* refactor(ptc): keep sandbox policy dispatch synchronous

The policy cap is a pure, cheap computation, so the waterfall should not force
every confined program through an await before the call is registered. The
event now returns the policy directly: no admission window between reading the
mode and registering the call, no async mode resolver, and no fallback branch
in PtcCalls. The event can still be dispatched twice for one Agent-owned
program; its contract names the synchronous, idempotent listener requirement
and tests lock both dispatch counts.

* docs(ptc): state the synchronous sandbox-policy contract

The README now names the synchronous waterfall and the two policy resolutions
an Agent-owned program performs, so readers know listeners must be synchronous,
pure, idempotent, and return the same cap each time.

* fix(liveshare): let the declaration entry win the fallback race

A live bundle activation can start the share host before the separate
declaration entry's service is visible in the host context. The host now gives
that entry one task turn before providing its own fallback surface, so both
rows no longer register `liveshareViewerDeclarations` twice.

* chore(liveshare): drop the now-unused require-await suppression

The deferred fallback makes apply genuinely await, so the file no longer needs
the suppression it carried for a synchronous throw.

* fix(liveshare): read the owner Remote namespace after mounting it

The client face accessed `remote.liveshareShares` on its own context before
that namespace existed, which the Remote carrier refuses without an inject
entry. The header action now registers inside a child scope injected after the
carrier mounts, and the face tests provide the mounted namespace.

* feat(liveshare): simplify the owner share dialog

Saving the relay address now checks it in the same action, and the numbered
step guide is gone. Sign-in is a single control above the share settings, and
every setting below it stays disabled until the owner signs in. Fork wording
and the read-only permission hint now state the actual permissions.

* feat(liveshare): save the relay address on blur

The address field no longer needs a Save button: leaving the field (or pressing
Enter) stores it and probes the address it put in force. Chinese copy now uses
观看者 consistently instead of mixing viewer and 观看者.

* chore(ptc): restore the run signature formatting

The synchronous policy refactor left only a line-wrap difference in this file;
the signature returns to its original one-line form.

* feat(liveshare): configure plugin sharing when creating a share

The create form now carries the same share-wide plugin-endpoint tier as the
stored-share editor and writes it immediately after the host creates the
share. The Advanced disclosure only renders for an existing share, where it
has stored-share details to show.

* fix(liveshare): show the owner name on shared-message attribution

The durable source names the reader by subject id, so the line showed the opaque
id even when the reader was the owner. The client now remembers the verified
owner identity it reads on mount, and the attribution uses that display name for
the matching subject while keeping the persisted id for every other reader.

* feat(liveshare): use the viewer's Relay name in shared-message attribution

The viewer context already carries the reader's own display name; reading it
lets a viewer's messages show their name instead of the opaque subject id,
while a reader with no reported name keeps the durable id.

* feat(liveshare): persist the viewer display name in message attribution

The Relay asserts a display name for the viewer it forwards. Copying that name
into the durable share-viewer principal lets the owner and every reader show
who sent a message, instead of only the current reader or an opaque subject id.
The name is attribution data only and stays out of authorization and model
requests; old logs and readers without it keep showing the subject id.

* feat(liveshare): share the permission fields between create and edit

Creating and managing a share now render the same session permission, fork
switch, and plugin-endpoint fields, and the stored-share view states its
lifetime and link scope inline instead of behind an empty Advanced disclosure.
The first version publishes only the never-expiring lifetime.

* feat(liveshare): edit a share lifetime and link scope after creation

`updatePermissions` now accepts a new deadline (null means never) and the
open/selected link scope. The shared permission fields expose both while
creating and editing; an existing share can be switched to the open link or
cleared back to never, and selected shares accept provider subject ids.
LiveShare prose now calls every fork product a 分叉会话.

* test(liveshare): remove duplicate lint suppression

* fix(liveshare): keep row labels on one line

* fix(liveshare): clear the static catalog and unknown-cast gates

The owner-display test no longer casts through unknown, and the generated
Cordis runtime catalog now includes the extended permission request type.

* test(liveshare): cover the unchanged update and subject-order branches

* test(liveshare): cover the unchanged restored-access branch

* fix(liveshare): re-probe a stale owner credential

* refactor(liveshare): remove the unfinished selected-colleague scope

The share dialog no longer offers or edits a selected-colleague link scope;
new shares use the organization link and stored legacy scopes stay read-only.
The create form's lifetime is the single never-expiring row, and the host
identity read re-probes a stale credential.

* feat(liveshare): simplify the share manager and add plugin sharing

The global manager now lists Session titles and opens the matching Session's
share dialog, which names the Session it edits and exposes one plugin-sharing
switch. Shares can still be listed without any plugin declaring endpoints, and
the switch states that absence.

* fix(liveshare): open the selected share from the manager

The manager's Manage action now opens that Session's share dialog directly,
and binds workspace navigation when the page has it. The rows use one grid so
titles, online state, and actions line up, and the footer offers Cancel next to
Done.

* refactor(liveshare): elect shared-session attribution through a chain seat

Chat now declares `conversation.chat.user.before` as a chain seat whose owner
props carry the durable source and row kind. Liveshare's selector elects only
share-viewer user rows, so the component no longer probes or returns null, and
the official user row stays unchanged. The manager aligns its columns, adds a
per-share cancellation action, and no longer offers a footer cancel that meant
the window rather than a share.

* refactor(liveshare): drop PTC sharing from this change

The share surface now admits only the native read/write tools. PTC
run_code admission, its sandbox-policy cap, and the executor-side policy
extension move to a separate change, so this PR keeps non-PTC sharing focused.
Core PTC files, sandbox docs, and generated catalogs return to master.

* docs(liveshare): fold the viewer display name into the principal record

The optional displayName is part of the share-viewer principal, so its
persistence acknowledgement now lives in the 2026-10-13 principal record
instead of a separate 2026-10-27 record.

* refactor(liveshare): render user attribution through its own chain slot

* refactor(liveshare): keep one user message renderer for the attribution seat

* refactor(liveshare): render the attribution seat inside the user bubble

* docs(liveshare): regenerate the event graph pages

* test(liveshare): close the endpoint control coverage gaps

Cover the endpoint tier control's empty-offer return and drop the unused expiry choice list.

* chore(docs): regenerate the persistence catalogs after rebasing onto master

* chore(liveshare): carry the 0.2.2-alpha.1 release version
2026-10-28 01:44:19 +08:00

68 KiB
Raw Blame History

能力 Seams 与核心服务

English | 中文

服务可以是核心主干服务、可替换的能力 seam、组合包/组合点或独立服务。下图展示了拥有服务声明的包、已知实现包,以及直接消费该服务的包。

flowchart LR
  pkg_action_cards["action-cards"]
  svc_actionCards["ctx.actionCards<br/>Optional action cards"]
  pkg_creation_recommendations["creation-recommendations"]
  pkg_client_ui_action_cards["client-ui-action-cards"]
  pkg_plugin_recommendations["plugin-recommendations"]
  svc_pluginRecommendations["ctx.pluginRecommendations<br/>Explicit-need plugin recommendations"]
  pkg_client_ui_plugin_recommendations["client-ui-plugin-recommendations"]
  pkg_headless["headless"]
  svc_headlessStartup["ctx.headlessStartup<br/>Headless invocation options"]
  pkg_experimental_client_ui_cot_translation["experimental-client-ui-cot-translation"]
  svc_cotTranslation["ctx.cotTranslation<br/>Reasoning translation Remote"]
  pkg_experimental_translator["experimental-translator"]
  svc_translator["ctx.translator<br/>Anonymous text translation"]
  pkg_hmr["hmr"]
  svc_hmr["ctx.hmr<br/>Serialized module and configuration reloads"]
  pkg_app_boot["app-boot"]
  pkg_client_ui_plugin_manager["client-ui-plugin-manager"]
  svc_pluginRegistryProbe["ctx.pluginRegistryProbe<br/>Host registry response comparison"]
  pkg_plugin_manager["plugin-manager"]
  svc_pluginManager["ctx.pluginManager<br/>Current-profile plugin and bundle management"]
  pkg_ui_settings_plugin_inventory["ui-settings-plugin-inventory"]
  pkg_plugin_market["plugin-market"]
  svc_pluginMarket["ctx.pluginMarket<br/>Plugin market index reader"]
  pkg_client_ui_plugin_market["client-ui-plugin-market"]
  svc_profileContext["ctx.profileContext<br/>Launcher-owned profile data"]
  pkg_client_connection["client-connection"]
  svc_connection["ctx.connection<br/>Authenticated browser transport"]
  pkg_api_gateway["api-gateway"]
  pkg_host_frontend_static["host-frontend-static"]
  pkg_experimental_forge["experimental-forge"]
  svc_forge["ctx.forge<br/>Code host change requests"]
  pkg_experimental_forge_github["experimental-forge-github"]
  pkg_experimental_forge_session["experimental-forge-session"]
  pkg_experimental_client_ui_forge["experimental-client-ui-forge"]
  svc_forgeSession["ctx.forgeSession<br/>Session change request bindings"]
  svc_forgePanel["ctx.forgePanel<br/>Forge panel Remote"]
  pkg_experimental_worktree["experimental-worktree"]
  svc_worktrees["ctx.worktrees<br/>Git worktree creation"]
  pkg_experimental_tool_worktree["experimental-tool-worktree"]
  pkg_working_directory["working-directory"]
  svc_workingDirectory["ctx.workingDirectory<br/>Session working directory"]
  pkg_tool_working_directory["tool-working-directory"]
  pkg_tool_fs["tool-fs"]
  pkg_tool_bash["tool-bash"]
  pkg_tool_pwsh["tool-pwsh"]
  pkg_subagent["subagent"]
  pkg_sdk_jsonrpc_server["sdk-jsonrpc-server"]
  pkg_mcp_resources["mcp-resources"]
  svc_mcpResources["ctx.mcpResources<br/>Scoped MCP resource access"]
  pkg_mcp_client["mcp-client"]
  pkg_browser_use["browser-use"]
  svc_browserUse["ctx.browserUse<br/>Browser-use provider registration"]
  pkg_experimental_browser_use_playwright_mcp["experimental-browser-use-playwright-mcp"]
  pkg_experimental_browser_use_chrome_devtools_mcp["experimental-browser-use-chrome-devtools-mcp"]
  pkg_experimental_browser_use_stagehand_native["experimental-browser-use-stagehand-native"]
  pkg_computer_use["computer-use"]
  svc_computerUse["ctx.computerUse<br/>Computer-use provider registration"]
  pkg_experimental_computer_use_cua_driver_mcp["experimental-computer-use-cua-driver-mcp"]
  pkg_experimental_computer_use_cua_driver_native["experimental-computer-use-cua-driver-native"]
  pkg_cua["cua"]
  svc_cuaAccess["ctx.cuaAccess<br/>Computer Use permission controls"]
  pkg_office_to_pdf["office-to-pdf"]
  svc_officeToPdf["ctx.officeToPdf<br/>Office to PDF conversion"]
  pkg_client_ui_sidebar_documentpreview["client-ui-sidebar-documentpreview"]
  pkg_attachment["attachment"]
  svc_attachments["ctx.attachments<br/>Durable binary attachment storage"]
  pkg_attachment_local["attachment-local"]
  pkg_api_session_controller["api-session-controller"]
  pkg_llm_pi_ai["llm-pi-ai"]
  pkg_llm_deepseek["llm-deepseek"]
  pkg_client_file_upload["client-file-upload"]
  svc_fileUploads["ctx.fileUploads<br/>Agent-scoped staged file uploads"]
  pkg_llm["llm"]
  svc_llm["ctx.llm<br/>LLM adapter registry"]
  pkg_llm_replay["llm-replay"]
  pkg_agent_loop["agent-loop"]
  pkg_compaction_basic["compaction-basic"]
  pkg_deepseek_llm_api_extensions["deepseek-llm-api-extensions"]
  svc_deepseekLlmApiExtensions["ctx.deepseekLlmApiExtensions<br/>Official DeepSeek request extensions"]
  pkg_session_log_deepseek["session-log-deepseek"]
  pkg_plugin_package_inventory_deepseek["plugin-package-inventory-deepseek"]
  pkg_token_meter["token-meter"]
  svc_tokenMeter["ctx.tokenMeter<br/>Replay token measurement"]
  pkg_compaction_tool_result_pruner["compaction-tool-result-pruner"]
  svc_toolResultPruner["ctx.toolResultPruner<br/>Model-free tool-result pruning"]
  pkg_session["session"]
  svc_sessions["ctx.sessions<br/>In-memory session store"]
  pkg_agent["agent"]
  pkg_session_persistence["session-persistence"]
  pkg_session_query["session-query"]
  pkg_session_query_sqlite["session-query-sqlite"]
  pkg_message_feedback["message-feedback"]
  pkg_experimental_api_speech_to_text["experimental-api-speech-to-text"]
  svc_speechController["ctx.speechController<br/>Experimental transcription Remote"]
  svc_sessionController["ctx.sessionController<br/>Host Session Remote controller"]
  svc_sessionFileReferences["ctx.sessionFileReferences<br/>Session-addressed file-reference Remote adapter"]
  svc_sessionSkillCatalog["ctx.sessionSkillCatalog<br/>Session-addressed skill Remote adapter"]
  pkg_api_job_controller["api-job-controller"]
  svc_jobController["ctx.jobController<br/>Host job Remote controller"]
  pkg_api_settings_controller["api-settings-controller"]
  svc_credentialsController["ctx.credentialsController<br/>Host credential-surface Remote controller"]
  svc_settingsController["ctx.settingsController<br/>Host settings-surface Remote controller"]
  pkg_api_workspace_files["api-workspace-files"]
  svc_workspaceFiles["ctx.workspaceFiles<br/>Host workspace file Remote service"]
  pkg_workspace_changes["workspace-changes"]
  svc_workspaceChanges["ctx.workspaceChanges<br/>Host per-turn changed-file summaries"]
  pkg_api_terminal_controller["api-terminal-controller"]
  svc_terminalController["ctx.terminalController<br/>Session interactive terminal Remote controller"]
  pkg_api_workspace_controller["api-workspace-controller"]
  svc_workspaceController["ctx.workspaceController<br/>Host Workspace Remote controller"]
  svc_directoryPickerController["ctx.directoryPickerController<br/>Host directory-picking Remote controller"]
  pkg_typert_registry["typert-registry"]
  svc_typert["ctx.typert<br/>Runtime type registry"]
  pkg_typert_loader["typert-loader"]
  svc_typertGateway["ctx.typertGateway<br/>Typert Host invocation gateway"]
  pkg_api_remote_access["api-remote-access"]
  svc_remoteAccess["ctx.remoteAccess<br/>Remote method access control"]
  svc_sessionPersistence["ctx.sessionPersistence<br/>Durable session persistence seam"]
  pkg_session_persistence_jsonl["session-persistence-jsonl"]
  pkg_hooks_claude_code["hooks-claude-code"]
  pkg_hooks_codex["hooks-codex"]
  pkg_config_editor["config-editor"]
  svc_configEditor["ctx.configEditor<br/>Profile configuration edits"]
  pkg_settings["settings"]
  pkg_agent_default_model["agent-default-model"]
  svc_settings["ctx.settings<br/>Plugin configuration forms"]
  pkg_tool_subagent["tool-subagent"]
  svc_subagentModelSelection["ctx.subagentModelSelection<br/>Subagent model-selection preference"]
  pkg_credentials["credentials"]
  svc_credentials["ctx.credentials<br/>Credential seam"]
  pkg_credentials_local["credentials-local"]
  pkg_deepseek_account["deepseek-account"]
  svc_deepseekAccount["ctx.deepseekAccount<br/>DeepSeek account"]
  pkg_deepseek_account_platform["deepseek-account-platform"]
  pkg_api_account_controller["api-account-controller"]
  pkg_authorization["authorization"]
  svc_authorization["ctx.authorization<br/>Authorization flow registry"]
  pkg_client_product_analytics["client-product-analytics"]
  svc_productAnalytics["ctx.productAnalytics<br/>Desktop interaction collection"]
  pkg_otel["otel"]
  svc_otel["ctx.otel<br/>Shared OTel reporting channels"]
  pkg_host_product_telemetry_otel["host-product-telemetry-otel"]
  pkg_session_telemetry_otel["session-telemetry-otel"]
  svc_productTelemetry["ctx.productTelemetry<br/>Product usage event sender"]
  pkg_session_telemetry["session-telemetry"]
  svc_sessionTelemetry["ctx.sessionTelemetry<br/>Session telemetry seam"]
  pkg_storage["storage"]
  svc_storage["ctx.storage<br/>Non-session storage hub"]
  pkg_storage_json["storage-json"]
  pkg_storage_sqlite["storage-sqlite"]
  pkg_storage_domain["storage-domain"]
  svc_storageDomain["ctx.storageDomain<br/>Domain data facility"]
  pkg_workspace["workspace"]
  svc_messageFeedback["ctx.messageFeedback<br/>Lifecycle-bound message feedback"]
  pkg_command_feedback["command-feedback"]
  svc_sessionFeedback["ctx.sessionFeedback<br/>Session-level feedback recorder"]
  svc_workspaceRegistry["ctx.workspaceRegistry<br/>Workspace entity registry"]
  svc_sessionQuery["ctx.sessionQuery<br/>Session reads, traces, filters, and search"]
  pkg_session_reference["session-reference"]
  pkg_tool_session_query["tool-session-query"]
  pkg_file_reference["file-reference"]
  svc_fileReferences["ctx.fileReferences<br/>File reference discovery"]
  pkg_file_reference_local["file-reference-local"]
  svc_sessionReferenceResolver["ctx.sessionReferenceResolver<br/>Cross-session snapshot preparation"]
  pkg_session_title["session-title"]
  svc_sessionTitle["ctx.sessionTitle<br/>Log-backed session titles"]
  pkg_session_title_first_prompt_llm["session-title-first-prompt-llm"]
  pkg_session_title_all_prompts_llm["session-title-all-prompts-llm"]
  pkg_system_prompt["system-prompt"]
  svc_systemPrompt["ctx.systemPrompt<br/>System prompt assembly registry"]
  pkg_tools["tools"]
  pkg_tool_terminal["tool-terminal"]
  pkg_tool_web["tool-web"]
  svc_tools["ctx.tools<br/>Scoped tool registry and executor selection"]
  pkg_tool_ask_user["tool-ask-user"]
  pkg_tool_cordis["tool-cordis"]
  pkg_tool_skill["tool-skill"]
  pkg_tool_todo["tool-todo"]
  pkg_user_questions["user-questions"]
  svc_userQuestions["ctx.userQuestions<br/>Human question/answer seam"]
  pkg_plan_mode["plan-mode"]
  svc_planMode["ctx.planMode<br/>Plan collaboration state"]
  pkg_agent_preset_registry["agent-preset-registry"]
  svc_agentPresets["ctx.agentPresets<br/>Per-session agent composition"]
  pkg_commands["commands"]
  svc_commands["ctx.commands<br/>Human command registry"]
  pkg_session_projection["session-projection"]
  svc_sessionProjections["ctx.sessionProjections<br/>Session projection units"]
  pkg_session_projection_cache["session-projection-cache"]
  svc_sessionProjectionCache["ctx.sessionProjectionCache<br/>Persisted projection cache"]
  pkg_skill["skill"]
  svc_skills["ctx.skills<br/>Skill provider registry"]
  pkg_sandbox_windows_acl["sandbox-windows-acl"]
  pkg_skill_badge["skill-badge"]
  pkg_skill_filesystem["skill-filesystem"]
  pkg_skill_office["skill-office"]
  svc_agents["ctx.agents<br/>Agent service"]
  pkg_acp["acp"]
  svc_agentDefaultModel["ctx.agentDefaultModel<br/>Default Agent model selection"]
  svc_agentLoop["ctx.agentLoop<br/>Concrete loop driver"]
  pkg_base["base"]
  pkg_sdk_minimal["sdk-minimal"]
  pkg_schedule["schedule"]
  svc_schedule["ctx.schedule<br/>Host scheduled messages"]
  pkg_goal["goal"]
  svc_goals["ctx.goals<br/>Same-session goal domain"]
  pkg_ssh["ssh"]
  svc_ssh["ctx.ssh<br/>POSIX SSH connection owner"]
  pkg_fs_ssh["fs-ssh"]
  pkg_subprocess_ssh["subprocess-ssh"]
  pkg_sandbox_ssh["sandbox-ssh"]
  pkg_subprocess["subprocess"]
  svc_subprocess["ctx.subprocess<br/>Subprocess seam"]
  pkg_subprocess_local["subprocess-local"]
  pkg_bash_local["bash-local"]
  pkg_bash_sandbox["bash-sandbox"]
  pkg_terminal_bash["terminal-bash"]
  pkg_lsp_stdio["lsp-stdio"]
  pkg_subagent_acp["subagent-acp"]
  pkg_subagent_codex["subagent-codex"]
  pkg_subagent_claude_code["subagent-claude-code"]
  pkg_shell["shell"]
  svc_shell["ctx.shell<br/>Bash executor seam"]
  pkg_pwsh_local["pwsh-local"]
  pkg_shell_env["shell-env"]
  svc_shellEnv["ctx.shellEnv<br/>Managed bash environment registry"]
  pkg_terminal["terminal"]
  svc_terminals["ctx.terminals<br/>Persistent PTY session registry"]
  pkg_sandbox["sandbox"]
  svc_sandbox["ctx.sandbox<br/>Process-sandbox seam"]
  pkg_sandbox_local["sandbox-local"]
  pkg_sandbox_policy["sandbox-policy"]
  svc_sandboxPolicy["ctx.sandboxPolicy<br/>Sandbox policy home"]
  pkg_fs_sandbox["fs-sandbox"]
  pkg_user_approval["user-approval"]
  svc_approval["ctx.approval<br/>Approval seam"]
  pkg_permission_presets["permission-presets"]
  svc_permissionPresets["ctx.permissionPresets<br/>Permission presets"]
  pkg_ptc_runtime["ptc-runtime"]
  svc_ptcRuntime["ctx.ptcRuntime<br/>PTC execution seam"]
  pkg_ptc_runtime_node["ptc-runtime-node"]
  pkg_experimental_ptc_runtime_python["experimental-ptc-runtime-python"]
  pkg_tool_executor_ptc["tool-executor-ptc"]
  pkg_workflow_ptc["workflow-ptc"]
  pkg_fs["fs"]
  svc_fs["ctx.fs<br/>Filesystem provider seam"]
  pkg_fs_local["fs-local"]
  pkg_fs_observation_policy["fs-observation-policy"]
  pkg_compaction["compaction"]
  svc_compaction["ctx.compaction<br/>Compaction seam"]
  svc_subagents["ctx.subagents<br/>Subagent provider and continuation service"]
  pkg_subagent_spawn_in_process["subagent-spawn-in-process"]
  pkg_subagent_fork_in_process["subagent-fork-in-process"]
  pkg_subagent_dsh_sdk["subagent-dsh-sdk"]
  pkg_tool_subagent_control["tool-subagent-control"]
  pkg_tool_ralph["tool-ralph"]
  pkg_experimental_speech_to_text["experimental-speech-to-text"]
  svc_speechToText["ctx.speechToText<br/>Experimental speech recognition providers"]
  pkg_experimental_speech_to_text_sensevoice["experimental-speech-to-text-sensevoice"]
  pkg_experimental_agent_team["experimental-agent-team"]
  svc_agentTeams["ctx.agentTeams<br/>Agent Teams coordination domain"]
  pkg_experimental_tool_agent_team["experimental-tool-agent-team"]
  pkg_experimental_claude_code_mods["experimental-claude-code-mods"]
  svc_claudeCodeMods["ctx.claudeCodeMods<br/>Claude Code mods bridge"]
  pkg_inspector["inspector"]
  svc_inspector["ctx.inspector<br/>Cross-realm runtime inspection"]
  pkg_jobs["jobs"]
  svc_jobs["ctx.jobs<br/>Background job registry"]
  pkg_jobs_local["jobs-local"]
  pkg_tool_jobs["tool-jobs"]
  pkg_web["web"]
  svc_web["ctx.web<br/>Web access provider registry"]
  pkg_web_search_exa["web-search-exa"]
  pkg_web_search_perplexity["web-search-perplexity"]
  pkg_web_search_deepseek["web-search-deepseek"]
  pkg_web_deepseek_api["web-deepseek-api"]
  pkg_web_fetch_http["web-fetch-http"]
  pkg_spill["spill"]
  svc_spillStore["ctx.spillStore<br/>Spill storage seam"]
  pkg_spill_local["spill-local"]
  pkg_spill_policy["spill-policy"]
  pkg_host_directory_picker["host-directory-picker"]
  svc_directoryPicker["ctx.directoryPicker<br/>Workspace-directory picking seam"]
  pkg_host_directory_picker_native["host-directory-picker-native"]
  pkg_host_directory_picker_browse["host-directory-picker-browse"]
  pkg_host_webserver["host-webserver"]
  svc_webServer["ctx.webServer<br/>HTTP route registration"]
  pkg_client_modules["client-modules"]
  pkg_client_hmr["client-hmr"]
  pkg_web_app["web-app"]
  svc_webApp["ctx.webApp<br/>Served Web GUI"]
  pkg_harness_dev_context["harness-dev-context"]
  svc_clientModules["ctx.clientModules<br/>Client plugin graph host"]
  pkg_workflow["workflow"]
  svc_workflowEngine["ctx.workflowEngine<br/>Workflow script engine"]
  pkg_tool_workflow["tool-workflow"]
  pkg_webhook["webhook"]
  svc_webhookRuntime["ctx.webhookRuntime<br/>Webhook rule runtime"]
  pkg_webhook_github["webhook-github"]
  pkg_lsp["lsp"]
  svc_lsp["ctx.lsp<br/>Language-server navigation seam"]
  pkg_tool_lsp["tool-lsp"]
  pkg_cordis_host_runner["cordis-host-runner"]
  svc_dynamicCordisRunner["ctx.dynamicCordisRunner<br/>Dynamic Cordis package host runner"]
  svc_cordisInspect["ctx.cordisInspect<br/>Dynamic Cordis inspect registry"]
  pkg_experimental_liveshare["experimental-liveshare"]
  svc_liveshareShares["ctx.liveshareShares<br/>Owner share management Remote"]
  pkg_action_cards --> svc_actionCards
  pkg_agent --> svc_agents
  pkg_agent_default_model --> svc_agentDefaultModel
  pkg_agent_loop --> svc_agentLoop
  pkg_agent_preset_registry --> svc_agentPresets
  pkg_api_gateway --> svc_typertGateway
  pkg_api_job_controller --> svc_jobController
  pkg_api_remote_access --> svc_remoteAccess
  pkg_api_session_controller --> svc_sessionController
  pkg_api_session_controller --> svc_sessionFileReferences
  pkg_api_session_controller --> svc_sessionSkillCatalog
  pkg_api_settings_controller --> svc_credentialsController
  pkg_api_settings_controller --> svc_settingsController
  pkg_api_terminal_controller --> svc_terminalController
  pkg_api_workspace_controller --> svc_directoryPickerController
  pkg_api_workspace_controller --> svc_workspaceController
  pkg_api_workspace_files --> svc_workspaceFiles
  pkg_app_boot --> svc_profileContext
  pkg_attachment --> svc_attachments
  pkg_attachment_local --> svc_attachments
  pkg_authorization --> svc_authorization
  pkg_bash_local --> svc_shell
  pkg_bash_sandbox --> svc_shell
  pkg_browser_use --> svc_browserUse
  pkg_client_connection --> svc_connection
  pkg_client_file_upload --> svc_fileUploads
  pkg_client_modules --> svc_clientModules
  pkg_client_product_analytics --> svc_productAnalytics
  pkg_client_ui_plugin_manager --> svc_pluginRegistryProbe
  pkg_command_feedback --> svc_sessionFeedback
  pkg_commands --> svc_commands
  pkg_compaction --> svc_compaction
  pkg_compaction_basic --> svc_compaction
  pkg_compaction_tool_result_pruner --> svc_toolResultPruner
  pkg_computer_use --> svc_computerUse
  pkg_config_editor --> svc_configEditor
  pkg_cordis_host_runner --> svc_cordisInspect
  pkg_cordis_host_runner --> svc_dynamicCordisRunner
  pkg_credentials --> svc_credentials
  pkg_credentials_local --> svc_credentials
  pkg_cua --> svc_cuaAccess
  pkg_deepseek_account --> svc_deepseekAccount
  pkg_deepseek_account_platform --> svc_deepseekAccount
  pkg_deepseek_llm_api_extensions --> svc_deepseekLlmApiExtensions
  pkg_experimental_agent_team --> svc_agentTeams
  pkg_experimental_api_speech_to_text --> svc_speechController
  pkg_experimental_browser_use_chrome_devtools_mcp --> svc_browserUse
  pkg_experimental_browser_use_playwright_mcp --> svc_browserUse
  pkg_experimental_browser_use_stagehand_native --> svc_browserUse
  pkg_experimental_claude_code_mods --> svc_claudeCodeMods
  pkg_experimental_client_ui_cot_translation --> svc_cotTranslation
  pkg_experimental_client_ui_forge --> svc_forgePanel
  pkg_experimental_computer_use_cua_driver_mcp --> svc_computerUse
  pkg_experimental_computer_use_cua_driver_native --> svc_computerUse
  pkg_experimental_forge --> svc_forge
  pkg_experimental_forge_github --> svc_forge
  pkg_experimental_forge_session --> svc_forgeSession
  pkg_experimental_liveshare --> svc_liveshareShares
  pkg_experimental_ptc_runtime_python --> svc_ptcRuntime
  pkg_experimental_speech_to_text --> svc_speechToText
  pkg_experimental_speech_to_text_sensevoice --> svc_speechToText
  pkg_experimental_translator --> svc_translator
  pkg_experimental_worktree --> svc_worktrees
  pkg_file_reference --> svc_fileReferences
  pkg_file_reference_local --> svc_fileReferences
  pkg_fs --> svc_fs
  pkg_fs_local --> svc_fs
  pkg_fs_sandbox --> svc_fs
  pkg_fs_ssh --> svc_fs
  pkg_goal --> svc_goals
  pkg_headless --> svc_headlessStartup
  pkg_hmr --> svc_hmr
  pkg_host_directory_picker --> svc_directoryPicker
  pkg_host_directory_picker_browse --> svc_directoryPicker
  pkg_host_directory_picker_native --> svc_directoryPicker
  pkg_host_product_telemetry_otel --> svc_productTelemetry
  pkg_host_webserver --> svc_webServer
  pkg_inspector --> svc_inspector
  pkg_jobs --> svc_jobs
  pkg_jobs_local --> svc_jobs
  pkg_llm --> svc_llm
  pkg_llm_deepseek --> svc_llm
  pkg_llm_pi_ai --> svc_llm
  pkg_llm_replay --> svc_llm
  pkg_lsp --> svc_lsp
  pkg_lsp_stdio --> svc_lsp
  pkg_mcp_client --> svc_mcpResources
  pkg_mcp_resources --> svc_mcpResources
  pkg_message_feedback --> svc_messageFeedback
  pkg_office_to_pdf --> svc_officeToPdf
  pkg_otel --> svc_otel
  pkg_permission_presets --> svc_permissionPresets
  pkg_plan_mode --> svc_planMode
  pkg_plugin_manager --> svc_pluginManager
  pkg_plugin_market --> svc_pluginMarket
  pkg_plugin_package_inventory_deepseek --> svc_deepseekLlmApiExtensions
  pkg_plugin_recommendations --> svc_pluginRecommendations
  pkg_ptc_runtime --> svc_ptcRuntime
  pkg_ptc_runtime_node --> svc_ptcRuntime
  pkg_pwsh_local --> svc_shell
  pkg_sandbox --> svc_sandbox
  pkg_sandbox_local --> svc_sandbox
  pkg_sandbox_policy --> svc_sandboxPolicy
  pkg_sandbox_ssh --> svc_sandbox
  pkg_sandbox_windows_acl --> svc_skills
  pkg_schedule --> svc_schedule
  pkg_session --> svc_sessions
  pkg_session_log_deepseek --> svc_deepseekLlmApiExtensions
  pkg_session_persistence --> svc_sessionPersistence
  pkg_session_persistence_jsonl --> svc_sessionPersistence
  pkg_session_projection --> svc_sessionProjections
  pkg_session_projection_cache --> svc_sessionProjectionCache
  pkg_session_query --> svc_sessionQuery
  pkg_session_query_sqlite --> svc_sessionQuery
  pkg_session_reference --> svc_sessionReferenceResolver
  pkg_session_telemetry --> svc_sessionTelemetry
  pkg_session_telemetry_otel --> svc_sessionTelemetry
  pkg_session_title --> svc_sessionTitle
  pkg_session_title_all_prompts_llm --> svc_sessionTitle
  pkg_session_title_first_prompt_llm --> svc_sessionTitle
  pkg_settings --> svc_settings
  pkg_shell --> svc_shell
  pkg_shell_env --> svc_shellEnv
  pkg_skill --> svc_skills
  pkg_skill_badge --> svc_skills
  pkg_skill_filesystem --> svc_skills
  pkg_skill_office --> svc_skills
  pkg_spill --> svc_spillStore
  pkg_spill_local --> svc_spillStore
  pkg_ssh --> svc_ssh
  pkg_storage --> svc_storage
  pkg_storage_domain --> svc_storageDomain
  pkg_storage_json --> svc_storage
  pkg_storage_sqlite --> svc_storage
  pkg_subagent --> svc_subagents
  pkg_subagent_acp --> svc_subagents
  pkg_subagent_claude_code --> svc_subagents
  pkg_subagent_codex --> svc_subagents
  pkg_subagent_dsh_sdk --> svc_subagents
  pkg_subagent_fork_in_process --> svc_subagents
  pkg_subagent_spawn_in_process --> svc_subagents
  pkg_subprocess --> svc_subprocess
  pkg_subprocess_local --> svc_subprocess
  pkg_subprocess_ssh --> svc_subprocess
  pkg_system_prompt --> svc_systemPrompt
  pkg_terminal --> svc_terminals
  pkg_terminal_bash --> svc_terminals
  pkg_token_meter --> svc_tokenMeter
  pkg_tool_subagent --> svc_subagentModelSelection
  pkg_tools --> svc_tools
  pkg_typert_registry --> svc_typert
  pkg_user_approval --> svc_approval
  pkg_user_questions --> svc_userQuestions
  pkg_web --> svc_web
  pkg_web_app --> svc_webApp
  pkg_web_deepseek_api --> svc_web
  pkg_web_fetch_http --> svc_web
  pkg_web_search_deepseek --> svc_web
  pkg_web_search_exa --> svc_web
  pkg_web_search_perplexity --> svc_web
  pkg_webhook --> svc_webhookRuntime
  pkg_workflow --> svc_workflowEngine
  pkg_workflow_ptc --> svc_workflowEngine
  pkg_working_directory --> svc_workingDirectory
  pkg_workspace --> svc_workspaceRegistry
  pkg_workspace_changes --> svc_workspaceChanges
  svc_actionCards --> pkg_client_ui_action_cards
  svc_actionCards --> pkg_creation_recommendations
  svc_agentDefaultModel --> pkg_api_session_controller
  svc_agentDefaultModel --> pkg_headless
  svc_agentLoop --> pkg_base
  svc_agentLoop --> pkg_sdk_minimal
  svc_agentTeams --> pkg_experimental_tool_agent_team
  svc_agents --> pkg_acp
  svc_agents --> pkg_agent_loop
  svc_agents --> pkg_subagent
  svc_approval --> pkg_acp
  svc_approval --> pkg_tool_bash
  svc_approval --> pkg_tools
  svc_attachments --> pkg_api_session_controller
  svc_attachments --> pkg_llm_deepseek
  svc_attachments --> pkg_llm_pi_ai
  svc_attachments --> pkg_tool_fs
  svc_authorization --> pkg_llm_pi_ai
  svc_browserUse --> pkg_experimental_browser_use_chrome_devtools_mcp
  svc_browserUse --> pkg_experimental_browser_use_playwright_mcp
  svc_browserUse --> pkg_experimental_browser_use_stagehand_native
  svc_clientModules --> pkg_client_hmr
  svc_compaction --> pkg_compaction_basic
  svc_computerUse --> pkg_experimental_computer_use_cua_driver_mcp
  svc_computerUse --> pkg_experimental_computer_use_cua_driver_native
  svc_configEditor --> pkg_agent_default_model
  svc_configEditor --> pkg_settings
  svc_connection --> pkg_api_gateway
  svc_connection --> pkg_host_frontend_static
  svc_cordisInspect --> pkg_tool_cordis
  svc_credentials --> pkg_api_settings_controller
  svc_credentials --> pkg_llm_deepseek
  svc_credentials --> pkg_llm_pi_ai
  svc_cuaAccess --> pkg_cua
  svc_deepseekAccount --> pkg_api_account_controller
  svc_deepseekAccount --> pkg_llm_deepseek
  svc_deepseekLlmApiExtensions --> pkg_llm_deepseek
  svc_directoryPicker --> pkg_api_workspace_controller
  svc_dynamicCordisRunner --> pkg_tool_cordis
  svc_fileReferences --> pkg_api_session_controller
  svc_fileUploads --> pkg_api_session_controller
  svc_forge --> pkg_experimental_client_ui_forge
  svc_forge --> pkg_experimental_forge_session
  svc_forgeSession --> pkg_experimental_client_ui_forge
  svc_fs --> pkg_tool_fs
  svc_headlessStartup --> pkg_headless
  svc_hmr --> pkg_app_boot
  svc_jobs --> pkg_api_job_controller
  svc_jobs --> pkg_tool_bash
  svc_jobs --> pkg_tool_jobs
  svc_jobs --> pkg_tool_pwsh
  svc_jobs --> pkg_tool_terminal
  svc_llm --> pkg_agent_loop
  svc_llm --> pkg_compaction_basic
  svc_lsp --> pkg_tool_lsp
  svc_mcpResources --> pkg_mcp_resources
  svc_officeToPdf --> pkg_client_ui_sidebar_documentpreview
  svc_otel --> pkg_host_product_telemetry_otel
  svc_otel --> pkg_session_telemetry_otel
  svc_pluginManager --> pkg_plugin_manager
  svc_pluginManager --> pkg_ui_settings_plugin_inventory
  svc_pluginMarket --> pkg_client_ui_plugin_market
  svc_pluginMarket --> pkg_plugin_market
  svc_pluginRecommendations --> pkg_client_ui_plugin_recommendations
  svc_pluginRegistryProbe --> pkg_client_ui_plugin_manager
  svc_profileContext --> pkg_plugin_manager
  svc_ptcRuntime --> pkg_tool_executor_ptc
  svc_ptcRuntime --> pkg_workflow_ptc
  svc_remoteAccess --> pkg_api_gateway
  svc_remoteAccess --> pkg_api_session_controller
  svc_remoteAccess --> pkg_api_workspace_controller
  svc_sandbox --> pkg_bash_sandbox
  svc_sandbox --> pkg_terminal_bash
  svc_sandboxPolicy --> pkg_bash_sandbox
  svc_sandboxPolicy --> pkg_fs_sandbox
  svc_sandboxPolicy --> pkg_terminal_bash
  svc_sessionPersistence --> pkg_agent_loop
  svc_sessionPersistence --> pkg_hooks_claude_code
  svc_sessionPersistence --> pkg_hooks_codex
  svc_sessionPersistence --> pkg_message_feedback
  svc_sessionPersistence --> pkg_session_query
  svc_sessionPersistence --> pkg_session_query_sqlite
  svc_sessionPersistence --> pkg_tool_bash
  svc_sessionProjectionCache --> pkg_api_session_controller
  svc_sessionProjectionCache --> pkg_session_query
  svc_sessionProjectionCache --> pkg_session_reference
  svc_sessionProjections --> pkg_api_session_controller
  svc_sessionProjections --> pkg_session_title
  svc_sessionProjections --> pkg_tool_todo
  svc_sessionQuery --> pkg_session_reference
  svc_sessionQuery --> pkg_tool_session_query
  svc_sessions --> pkg_agent
  svc_sessions --> pkg_agent_loop
  svc_sessions --> pkg_message_feedback
  svc_sessions --> pkg_session_persistence
  svc_sessions --> pkg_session_query
  svc_sessions --> pkg_session_query_sqlite
  svc_sessions --> pkg_subagent
  svc_settings --> pkg_api_settings_controller
  svc_shell --> pkg_hooks_claude_code
  svc_shell --> pkg_hooks_codex
  svc_shell --> pkg_tool_bash
  svc_shell --> pkg_tool_pwsh
  svc_shellEnv --> pkg_tool_bash
  svc_shellEnv --> pkg_tool_pwsh
  svc_skills --> pkg_tool_skill
  svc_speechToText --> pkg_experimental_api_speech_to_text
  svc_spillStore --> pkg_spill_policy
  svc_ssh --> pkg_fs_ssh
  svc_ssh --> pkg_sandbox_ssh
  svc_ssh --> pkg_subprocess_ssh
  svc_storage --> pkg_storage_domain
  svc_storageDomain --> pkg_workspace
  svc_subagentModelSelection --> pkg_tool_subagent
  svc_subagents --> pkg_tool_ralph
  svc_subagents --> pkg_tool_subagent
  svc_subagents --> pkg_tool_subagent_control
  svc_subprocess --> pkg_bash_local
  svc_subprocess --> pkg_bash_sandbox
  svc_subprocess --> pkg_lsp_stdio
  svc_subprocess --> pkg_subagent_acp
  svc_subprocess --> pkg_subagent_claude_code
  svc_subprocess --> pkg_subagent_codex
  svc_subprocess --> pkg_terminal_bash
  svc_systemPrompt --> pkg_agent_loop
  svc_systemPrompt --> pkg_tool_fs
  svc_systemPrompt --> pkg_tool_terminal
  svc_systemPrompt --> pkg_tool_web
  svc_systemPrompt --> pkg_tools
  svc_terminals --> pkg_tool_terminal
  svc_tokenMeter --> pkg_compaction_basic
  svc_toolResultPruner --> pkg_compaction_basic
  svc_tools --> pkg_agent_loop
  svc_tools --> pkg_tool_ask_user
  svc_tools --> pkg_tool_bash
  svc_tools --> pkg_tool_cordis
  svc_tools --> pkg_tool_fs
  svc_tools --> pkg_tool_skill
  svc_tools --> pkg_tool_subagent
  svc_tools --> pkg_tool_terminal
  svc_tools --> pkg_tool_todo
  svc_tools --> pkg_tool_web
  svc_translator --> pkg_experimental_client_ui_cot_translation
  svc_typert --> pkg_api_gateway
  svc_typert --> pkg_typert_loader
  svc_userQuestions --> pkg_tool_ask_user
  svc_web --> pkg_tool_web
  svc_webApp --> pkg_harness_dev_context
  svc_webServer --> pkg_client_connection
  svc_webServer --> pkg_client_hmr
  svc_webServer --> pkg_client_modules
  svc_webhookRuntime --> pkg_webhook_github
  svc_workflowEngine --> pkg_tool_ralph
  svc_workflowEngine --> pkg_tool_workflow
  svc_workingDirectory --> pkg_sdk_jsonrpc_server
  svc_workingDirectory --> pkg_subagent
  svc_workingDirectory --> pkg_tool_bash
  svc_workingDirectory --> pkg_tool_fs
  svc_workingDirectory --> pkg_tool_pwsh
  svc_workingDirectory --> pkg_tool_working_directory
  svc_workspaceRegistry --> pkg_api_session_controller
  svc_workspaceRegistry --> pkg_api_workspace_controller
  svc_worktrees --> pkg_experimental_tool_worktree
  svc_fs -. event gate .-> pkg_fs_observation_policy
ctx 键 角色 所属包 实现 直接消费方 配套插件 说明
ctx.actionCards service action-cards - creation-recommendations, client-ui-action-cards - 负责卡片工具、卡片状态、用户操作和状态通知;各卡片种类注册自己的动作和处理器。
ctx.pluginRecommendations service plugin-recommendations - client-ui-plugin-recommendations - 读取官方插件卡片的当前目录文本,并在用户点击后通过配置插件管理器启用该插件。
ctx.headlessStartup core headless - headless - 将解析后的任务和运行选项提供给无界面运行器及其 sandbox-policy 配置。
ctx.cotTranslation service experimental-client-ui-cot-translation - - - 为展开的思考内容提供有界的 Session 翻译请求,不改变模型可见历史。
ctx.translator service experimental-translator - experimental-client-ui-cot-translation - 解析 Google 或 Bing 请求,并可选保留统一的实验性 Session 记录。
ctx.hmr core hmr - app-boot - 负责模块和精确配置监听;应用修改共用其队列,自动重载等待应用文件锁。
ctx.pluginRegistryProbe core client-ui-plugin-manager - client-ui-plugin-manager - 在 Host 上并发比较公共安装源响应;初始安装源推荐由 Client 负责。
ctx.pluginManager core plugin-manager - plugin-manager, ui-settings-plugin-inventory - 与 CLI 共享 profile 包操作,并向 Web 和 Agent 调用方分别报告持久状态与运行状态。
ctx.pluginMarket core plugin-market - client-ui-plugin-market, plugin-market - 获取并校验用户配置的索引源;安装通过插件管理器完成。
ctx.profileContext core app-boot - plugin-manager - dsh launcher 提供纯数据形式的 profile 位置与组合输入;重载调度由 dsh-hmr 负责。
ctx.connection core client-connection - api-gateway, host-frontend-static - 负责浏览器认证与共享 HTTP 请求分发;API 适配器注册端点和流。
ctx.forge seam experimental-forge experimental-forge-github experimental-forge-session, experimental-client-ui-forge - 提供方映射远端与变更请求 URL、按 head 分支查找变更请求并批量读取状态;同一变更请求的监听方共享一个轮询循环。
ctx.forgeSession service experimental-forge-session - experimental-client-ui-forge - Session 投影从 shell 结果与绑定记录派生绑定,并把不含状态的 URL 发布给客户端;推送结果触发按 head 分支的发现,Session 监听方通过 forge 注册表轮询已绑定的变更请求。
ctx.forgePanel service experimental-client-ui-forge - - - 为每个被跟随的 Session 推送一份面板状态:在 Session 沙箱中进行的只读 Git 检查、识别出的代码托管平台及其登录状态,以及带轮询状态的已绑定变更请求。
ctx.worktrees seam experimental-worktree experimental-worktree experimental-tool-worktree - 显式实验组合从固定的本地提交创建工作树。检出目录与共享 Git 元数据受现有写权限约束;工作目录服务拥有创建后的 Session 目录。
ctx.workingDirectory seam working-directory working-directory tool-working-directory, tool-fs, tool-bash, tool-pwsh, subagent, sdk-jsonrpc-server - 一个 Session 投影拥有有效执行目录。文件系统验证变更,用户上下文报告目录信息,原始元数据与写入授权保持不变。
ctx.mcpResources seam mcp-resources mcp-client mcp-resources - 连接所有者提供的操作在调用 agent 的作用域内服务于共享资源工具。
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 - 每个服务实例注册一个提供方拥有的名称。提供方按实时 Session 拥有自己的工具与浏览器资源;共享服务不提供浏览器操作 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 - 每个服务实例只注册一个提供方自定的名称。各提供方也拥有自己的模型工具;服务不提供通用操作 API、运行时选择或 Session 流程锁。
ctx.cuaAccess core cua - cua - 原生 provider 负责应用授权和取消操作;可选的 Client 权限页面通过 Remote 查询和修改授权。
ctx.officeToPdf core office-to-pdf - client-ui-sidebar-documentpreview - 已授权的 Office 字节在宿主上使用已声明的原生目标引擎转换;未声明原生目标时使用 Node WASM。
ctx.attachments seam attachment attachment-local api-session-controller, tool-fs, llm-pi-ai, llm-deepseek - 宿主会在会话事件之前提交已接受的图片;提供方适配器将已授权的持久引用解析为提供方原生内容。
ctx.fileUploads core client-file-upload - api-session-controller - 负责流式接收、持久存储和暂存回执生命周期;Session Controller 将回执绑定到已接受的提交。
ctx.llm seam llm llm-deepseek, llm-pi-ai, llm-replay agent-loop, compaction-basic - 适配器注册提供方实现;agent loop(智能体循环)与压缩功能调用提供方无关的流服务。
ctx.deepseekLlmApiExtensions seam deepseek-llm-api-extensions session-log-deepseek, plugin-package-inventory-deepseek llm-deepseek - 插件准备彼此独立的顶层字段;官方适配器会合并这些字段,并在 HTTP 接受后提交其交付状态。
ctx.tokenMeter core token-meter - compaction-basic - 拥有按会话隔离的回放折叠区;压力消费方共享不可变且带修订版本的测量结果。
ctx.toolResultPruner core compaction-tool-result-pruner - compaction-basic - 在摘要压缩前,通过可回放的单节点表层替换来改写过大的当前工具结果。
ctx.sessions core session - agent-loop, agent, session-persistence, session-query, session-query-sqlite, subagent, message-feedback - 拥有仅追加的 Session 实例,并发出持久的会话事件流。
ctx.speechController core experimental-api-speech-to-text - - - 在 Provider 调用前校验受限的浏览器音频。
ctx.sessionController core api-session-controller - - - 负责 Session 命令、冷读取、持久事件跟随、实时控制状态、模型目录、workspace 打开与 Agent 激活策略。
ctx.sessionFileReferences core api-session-controller - - - 通过 Session Controller 的既有 Agent lookup 策略委托文件引用发现。
ctx.sessionSkillCatalog core api-session-controller - - - 在不激活冷 Agent 的前提下列出 Session 组合中允许用户调用的 skill。
ctx.jobController core api-job-controller - - - 经生成的 Remote namespace 流式发送一个后台任务的观测 record;名册仍在会话控制流上。
ctx.credentialsController core api-settings-controller - - - 把凭据引用 seam 投影到生成的 Remote namespace:批量扇出、视图投影与拒绝映射都在这里,而不在 seam Definition 上。
ctx.settingsController core api-settings-controller - - - 把用户设置 seam 投影到生成的 Remote namespace:读取一律脱敏,所有拒绝在这里分类,而不在 seam Definition 上。
ctx.workspaceFiles core api-workspace-files - - - 为会话工作区根内的文件提供 stat、分页文本、字节窗口、目录列举与变更流,经 lstat、包含关系与 stat 重检限定。
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 - - - 通过子进程提供方与类型化 Remote 传输管理用户终端进程、解析默认 shell,并恢复有界终端屏幕。
ctx.workspaceController core api-workspace-controller - - - 通过生成的 Remote namespace 负责 Workspace 命令和可在重连后收敛的 Workspace 状态投递。
ctx.directoryPickerController core api-workspace-controller - - - 把选目录 seam 送上线:能力门禁、取消传播,以及浏览器目录流程用于分支判断的 seam 错误码。
ctx.typert core typert-registry - typert-loader, api-gateway - 插件直接或通过 dsh-typert-loader 注册实时 zod 贡献;API 网关消费调用描述符和提供方,其他运行时消费方则在各自边界查询 schema 与反射元数据。
ctx.typertGateway core api-gateway - - - 将生成的 Remote 描述符与实时 Cordis 服务关联,解析已注册的身份,并通过共享的 Connection RPC 载体提供一元调用。
ctx.remoteAccess core api-remote-access - api-gateway, api-session-controller, api-workspace-controller - 通过业务方注册的基于 role 的 policy 判定非 owner Peer 可调用哪些 Remote 方法,过滤列表结果,并为每个 Peer 推送访问快照。
ctx.sessionPersistence seam session-persistence session-persistence-jsonl agent-loop, tool-bash, hooks-claude-code, hooks-codex, session-query, session-query-sqlite, message-feedback - JSONL backend 把 SessionEvent 词汇持久化为每个 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 - 拥有默认关闭的设置命名空间;Agent 作用域的委派工具会在组合新顶层 Session 时读取它。
ctx.credentials seam credentials credentials-local api-settings-controller, llm-deepseek, llm-pi-ai - 配置携带对机密信息的引用;提供方拥有实际值。消费方按操作解析,因此轮换后的凭据会在紧接着的下一次请求中生效;settings controller 提供不含实际值的视图和只写存储。
ctx.deepseekAccount seam deepseek-account deepseek-account-platform api-account-controller, llm-deepseek - Host 负责浏览器授权和本地凭证;UI 使用方只接收不含 token 的状态。
ctx.authorization seam authorization - llm-pi-ai - flow 由知道如何取得某份凭据的插件注册,并以其写入的记录为键;seam 拥有这段对话与"每个键同时只跑一次尝试"的生命周期,而非协议本身。
ctx.productAnalytics service client-product-analytics - - - 根据 Host 动态采集策略接收指定桌面事件、补充可用登录身份并监听实时压缩。
ctx.otel service otel - host-product-telemetry-otel, session-telemetry-otel - 产品埋点和 Session 反馈适配器通过同一个注入服务创建独立上报通道。
ctx.productTelemetry service host-product-telemetry-otel - - - 通过 OTLP/HTTP 发送显式提交的分析事件;仅挂载插件不会采集信息。
ctx.sessionTelemetry seam session-telemetry session-telemetry-otel - - 该 seam 捕获会话记录、进行脱敏并交给一个后端;没有其他组件消费该服务,其输出会离开当前进程。
ctx.storage seam storage storage-json, storage-sqlite storage-domain - 各后端以不同名称并列注册;数据形态(领域优先)挂载到枢纽上,并将类型化操作转换为不透明的 KV 单元原语。
ctx.storageDomain core storage-domain - workspace - 等待所有已配置后端就绪,然后将领域形态发布为一个受生命周期约束的服务,用于类型化持久状态。
ctx.messageFeedback core message-feedback - - - 拥有权威 Session 日志中的逐 assistant 消息反馈、目标校验、逐条目 compare-and-set 及 Host 一元 Remote 契约。反馈不进入模型历史;日志导出遵循消费方策略。
ctx.sessionFeedback core command-feedback - - - 通过 Host 一元 Remote 契约在 live Session 上把一条带分类的 Session 级评价记录为仅写日志的 feedback/record 事件;/feedback 命令共用同一个生产方。
ctx.workspaceRegistry core workspace - api-workspace-controller, api-session-controller - 通过领域设施拥有带 WorkspaceId 品牌类型的记录;稳定的 sessionIds 账户驱动 Host RPC 与 GUI 投影。
ctx.sessionQuery seam session-query session-query-sqlite session-reference, tool-session-query - 该接口提供精确读取、过滤和追踪;具体后端还提供全文协调、排序、摘要片段和游标世代,而模型消费方负责工作区权限与不含游标的渲染。
ctx.fileReferences seam file-reference file-reference-local api-session-controller - 该接口返回 Agent cwd 内仅含路径的补全候选;提供方负责命名空间访问与排序,但不读取文件内容。
ctx.sessionReferenceResolver core session-reference - - - 将当前表层中有界的对话快照投影为持久但不可信的消息上下文;Host 适配器负责提及语法。
ctx.sessionTitle seam session-title session-title-first-prompt-llm, session-title-all-prompts-llm - - 负责确定性回退、最新标题折叠区,以及唯一的可选异步提供方注册。
ctx.systemPrompt core system-prompt - agent-loop, tools, tool-fs, tool-terminal, tool-web - 为每个步骤收集提示词各部分和面向模型的工具 schema。
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 - 注册能力和作用域执行器。原生与 PTC 提供者负责工具描述及完整原始调用批次;它们可选用共享流水线处理工具策略和分发。
ctx.userQuestions seam user-questions - tool-ask-user - UI 前端提供当前生效的人工回答提供方;tool-ask-user 在提供方无关的 ask() promise 上暂停工具调用。
ctx.planMode core plan-mode - - - 折叠已记录的计划/模式状态,在轮次边界刷新用户选择,渲染由部署方拥有的指导信息,注册 /plan,并在状态转换期间保持计划退出 schema 稳定。
ctx.agentPresets core agent-preset-registry - - - 立即挂载 YAML 声明的 preset 版本,把 Agent 和冷读取绑定到作用域内的贡献,并保留已替换的版本,直到最后一个使用者释放它。
ctx.commands core commands - - - 插件注册直接面向人的命令,而不会把调用发送给模型。
ctx.sessionProjections core session-projection - api-session-controller, tool-todo, session-title - 各领域注册由状态驱动的折叠单元;主动驱动过程维护每个会话的水位状态,Session controller 提供 baseline 并推送发生变化的值。
ctx.sessionProjectionCache core session-projection-cache - api-session-controller, session-query, session-reference - 按会话持久保存投影单元状态的检查点(节流检查点,以及轮次/结束/分离时的必选检查点),提供缓存投影视图,并加速 prepared Session 的投影恢复。
ctx.skills seam skill sandbox-windows-acl, skill-badge, skill-filesystem, skill-office tool-skill - 合并提供方的 skill(技能)目录;tool-skill 渲染会话前缀目录,并加载完整的 skill 正文。
ctx.agents core agent - agent-loop, acp, subagent - 拥有实时 Agent 句柄、创建/恢复工厂 seam,以及进程本地的发起方传播。
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 - 唯一的具体循环插件;扩展包依赖 dsh-agent 的事件和服务,而不依赖此包。
ctx.schedule core schedule - - - 独立于 Session 的加载状态存储任务,并将到期消息排入原 Session。
ctx.goals core goal - - - 从会话日志折叠带修订版本的目标状态,并将实时延续激活保留在进程本地。
ctx.ssh core ssh - fs-ssh, subprocess-ssh, sandbox-ssh - 负责一条经过认证的 OpenSSH 连接、已安装辅助程序身份、独立程序流,以及配套远端提供方的断连清理。
ctx.subprocess seam subprocess subprocess-local, subprocess-ssh bash-local, bash-sandbox, terminal-bash, lsp-stdio, subagent-acp, subagent-codex, subagent-claude-code - Bash 执行器、PTY shell 后端、LSP Host,以及进程外 ACP、Codex 和 Claude Code subagent 后端都通过 ctx.subprocess 执行 spawn;该服务负责进程坐标、进程树/会话生命周期、stdio 处置、终端机制和 kill 升级。
ctx.shell seam shell bash-local, bash-sandbox, pwsh-local tool-bash, tool-pwsh, hooks-claude-code, hooks-codex - 面向模型的 shell 工具和钩子桥接消费此 seam;沙箱、远程或 PowerShell 执行器可以替换 bash-local,而无需改动这些消费方。
ctx.shellEnv core shell-env - tool-bash, tool-pwsh - 插件声明限定于 effect 作用域的 DSH_* 事实;每个 shell 工具在每次执行时收集一份可信快照,其执行器据此重建命名空间。
ctx.terminals seam terminal terminal-bash tool-terminal - 注册表负责精确到 Agent 的会话身份和清理;后端负责终端机制,tool-terminal 则提供限定于所有者作用域的模型接口。
ctx.sandbox seam sandbox sandbox-local, sandbox-ssh bash-sandbox, terminal-bash - 消费方交出即将执行 spawn 的确切 argv;与配套子进程提供方共享执行环境的后端按每次调用的策略包装该 argv,并报告强制执行情况。
ctx.sandboxPolicy core sandbox-policy - bash-sandbox, fs-sandbox, terminal-bash - 统一保存部署默认模式和工作区根目录;只有沙箱执行器和提供方读取该服务(工具层使用它同时导出的纯 sandbox/mode 折叠区)。两类强制执行组件都读取该服务,因此 bash 与 fs 不会限制到不同的根目录。
ctx.approval seam user-approval - tools, tool-bash, acp - 一次性权限决策通过 approval/request waterfall(瀑布式事件)分派;回答方是监听器(即 ACP 为自身 agent 提供的桥接),没有回答方时以 unavailable 关闭失败。
ctx.permissionPresets core permission-presets - - - 面向用户的预设表(workspace-write/danger-full-access),将沙箱模式与审批策略选项组合在一起;一次切换会写入一个 permission/preset 事件,并贯通到两个选项事件。
ctx.ptcRuntime seam ptc-runtime ptc-runtime-node, experimental-ptc-runtime-python tool-executor-ptc, workflow-ptc - 使用 Host 提供的异步绑定运行程序;tool-executor-ptc 负责 PTC 呈现,workflow-ptc 负责工作流编排。
ctx.fs seam fs fs-local, fs-sandbox, fs-ssh tool-fs fs-observation-policy tool-fs 通过 ctx.fs 执行读取/写入/编辑;fs-sandbox 按共享沙箱模式限制变更;fs-observation-policy 通过 fs/* 事件门禁贡献基于观测状态的检查。
ctx.compaction seam compaction compaction-basic compaction-basic - 基础后端消费步骤后的压力事件和请求错误恢复事件;不存在面向模型的压缩工具。
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 - 提供方准备本地子级或执行外部任务;一个 activation 管理器持有两类生命周期。委派工具选择后端,控制工具投递本地后续消息,工作流等待 activation 结果。
ctx.speechToText seam experimental-speech-to-text experimental-speech-to-text-sensevoice experimental-api-speech-to-text - 路由显式选择的识别器;浏览器使用带认证的 Remote,并在提交前将转写保留在草稿中。
ctx.agentTeams core experimental-agent-team - experimental-tool-agent-team - 负责隐式 Root roster、直接 peer inbox 投递、共享任务 DAG 与 continuable child 生命周期;tool-agent-team 提供模型控制工具。
ctx.claudeCodeMods core experimental-claude-code-mods - - - 加载 defineMod 插件添加的模组,从 harness 扩展点触发其钩子链,并通过其 Remote 绘制提示框上方的横幅。
ctx.inspector core inspector - - - 负责 Worker 托管的 CDP target,以及独立于传输的 Host 和 Client observation 与 Cordis tree query API。
ctx.jobs seam jobs jobs-local tool-bash, tool-pwsh, tool-terminal, tool-jobs, api-job-controller - 生产方(后台 bash/pwsh 与 PTY 发送)登记正在运行的工作;声明 record 的 job 还为非消费观察者流式提供原始输出;tool-jobs 是面向模型的控制器,用于读取、列出和终止这些工作;jobs-local 是进程本地注册表。
ctx.web seam web web-search-exa, web-search-perplexity, web-search-deepseek, web-deepseek-api, web-fetch-http tool-web - 搜索和抓取提供方注册到同一个 ctx.web seam;tool-web 负责稳定的面向模型名称。
ctx.spillStore seam spill spill-local spill-policy - 后端保存过大的工具文本,并返回面向模型的定位信息和取回提示;spill-policy 是 tools/post-execute 消费方,负责决定何时 spill。
ctx.directoryPicker seam host-directory-picker host-directory-picker-native, host-directory-picker-browse api-workspace-controller - 带判别标记的交互能力:原生后端在 Host 显示设备上打开一个操作系统选择器,浏览后端为应用内浏览器提供列表与创建原语;双端后端通过其浏览器侧填充 ui-workspace 目录流程的 slot(不通过协议发布)。
ctx.webServer core host-webserver - client-connection, client-modules, client-hmr - 普通的 node:http 载体:具名路由注册表、索引转换 tap,以及静态 dist 回退;Web 传输插件注册自己的路由。
ctx.webApp core web-app - harness-dev-context - web-runtime 行为其 Web GUI 公告一个 URL:配置了 publicUrl 时用它,否则用监听器 origin;DSH_WEB_URL、启动 URL 与 harness-dev-context 读取同一个值。
ctx.clientModules core client-modules - client-hmr - 通过增量 dsh.client 扫描组合 DSH_BOOT 入口图,提供插件组合包,并通知重建/图变更订阅方。
ctx.workflowEngine seam workflow workflow-ptc tool-workflow, tool-ralph - 每个上下文使用一个引擎,与 bash 相同,且没有具名提供方注册表;通用工作流与固定 Ralph 消费方启动运行,其中的 agent() 调用通过 ctx.subagents 扇出。
ctx.webhookRuntime core webhook - webhook-github - 提供方适配器分派已认证交付;可信插件注册独立的进程本地规则,runtime 把非 null 结果转换为普通的 Workspace-backed Session,不保留交付或完成状态。
ctx.lsp seam lsp lsp-stdio tool-lsp - 提供方注册与选择,加上恰好四种操作的标准化查询执行;该 seam 不提供协议逃生口,后端必须转换为标准化请求和结果。
ctx.dynamicCordisRunner core cordis-host-runner - tool-cordis - 拥有内存定义注册表、Host 半的 vm 沙箱和 request-run 往返流程;浏览器页面通过其 Remote 命名空间在线访问同一服务。
ctx.cordisInspect core cordis-host-runner - tool-cordis - 注册 Host inspect 提供方、镜像 Client 提供方 manifest,并通过动态 Cordis 传输路由 Client 查询。
ctx.liveshareShares service experimental-liveshare - - - 以单个 Typert Remote 命名空间发布 owner 分享管理操作,供 owner 客户端面调用;每个方法都委托给同源路由原先使用的同一组操作。

维护模式:混合模式。服务从 Cordis 声明中发现;接口、实现和消费方角色在 scripts/gen-doc-graphs.ts 中分类,并设有完整性守卫。