7 Commits

Author	SHA1	Message	Date
Jakub Zych	fe3ed06691	chore: clear dead test and allowlist leftovers of dropped runtimes	2026-10-06 20:35:12 +02:00
Jakub Zych	792139b5ed	chore: sweep Kimi mentions from comments and notes	2026-10-06 20:19:17 +02:00
Jakub Zych	6cfa0c55d2	refactor: drop 12 runtimes, keep Claude, Codex, OpenCode, Cursor, ZCode, Antigravity ... Removes kilo, kimi, kimi-code, copilot, windsurf, augment, trae, qwen, hermes, cline, codebuddy and pi end to end: capability descriptors, installer branches and converters (bin/install.js 14.9k -> 11.2k lines), TypeScript converters, hook surfaces and runtime homes, review lanes qwen/kimi-code, the two pi migrations, Kimi payload normalization in the hook guards, dead hostBehaviors vocabulary, launcher home probes, fixtures, runtime-specific tests and the prose that presented them as supported. Installer output for the six kept runtimes is byte-identical to before the prune. The Kimi tool-vocabulary tests in workflow-guard, read-guard and read-injection-scanner are left in place pending a decision.	2026-10-06 20:02:40 +02:00
Jakub Zych	a9a7a328e6	refactor: hard-fork GSD -> MSD (Make Software Done) ... Mechanical rename produced by scripts/msd-rename.cjs: gsd/Gsd/GSD -> msd/Msd/MSD across contents and paths, upstream package/repo coordinates -> @golem15/msd-core and golem15com/msd-core. Deep links into upstream history, sibling upstream packages, the GSD-2 import feature, CHANGELOG.md and .changeset/ are kept as-is. Hand edits on top: MSD block-letter banner and logos, LICENSE copyright line, package/plugin identity, regenerated lockfile, install-tree fixtures, derived registries and benchmark baseline; migration checksum baseline re-locked (MSD keeps its own install state, so no install had applied the old sums); sort-order and regex-escaped expectations in tests adjusted.	2026-10-06 01:47:40 +02:00
Zy Deng	4c60879b5d	fix(#4132): verify durable runtime surface sources (#4182) ... * fix(#4132): verify durable runtime surface sources * chore(#4132): record PR number in changeset * test(#4132): cover rejected commands source alias * fix(#4132): reject aliased package fallback * test(#4132): cover rejected agents source alias * test(#4132): cover partially aliased marker provider * fix(#4132): reject partially aliased source providers * test(#4132): cover routed source identity probes * fix(#4132): route installed source identity probes * refactor(#4132): tighten installer source metadata * test(#4132): cover corpus trust boundary attacks * fix(#4132): close installed corpus trust gaps * refactor(#4132): keep installer authority private * fix(#4132): preserve private installer fallback * test(#4132): preserve fixture source authority * fix(#4132): reject overlapping source fallback * fix(#4132): avoid redundant installed corpus reads * refactor(#4132): simplify provider resolution * test(#4132): sync install tree fixtures after rebase --------- Co-authored-by: Tom Boucher <trekkie@nomorestars.com>	2026-09-05 15:32:52 -04:00
Behruz Nassre Esfahani	a44d513566	fix(#3712): confine in-process installs to a sandboxed HOME (#3725) ... * fix(#3712): confine in-process installs to a sandboxed HOME A runtime kind may declare a global `home` override resolved from os.homedir() rather than from the caller's configDir — codex's skills kind (`home: ".agents"`, ADR-1239 / #2088) is the only live case. Sandboxing configDir/targetDir does not contain it, and assertDestWithinConfigHome cannot see the class: that gate confines a destSubpath to whatever root it is handed, and here the root IS the escaped home. So an in-process caller that forgot to sandbox HOME wrote to, and pruned gsd-* entries from, the developer's REAL ~/.agents/skills. tests/agent-descriptor-parity.install.test.cjs's K1 loop did exactly that: it iterates every agents-kind runtime (codex included) with a sandboxed targetDir and an un-sandboxed HOME. Reproduced against a canary home on next @ adb46cdd8 — 71 gsd-* skill dirs deleted, a foreign `cloudflare` skill surviving, suite still exit 0. It is silent because the runtime's own config home is untouched, so the manifest keeps reporting a healthy install. FIVE writers resolve a kind `home` and then destroy under it. Three are reachable today — installRuntimeArtifacts, uninstallRuntimeArtifacts (install-engine.cts) and applySurface (surface.cts). Two are descriptor-dependent and guarded against a future descriptor change rather than a present escape: installOpencodeFamilySkills (behind the combined-family early return) and installAgentsKindStandalone. Those two are scoped to the single kind each destroys — passing the whole layout made codex's unrelated skills override trip a writer that never touches it. - src/test-home-guard.cts: refuse when a run under a test runner cannot be shown to have sandboxed HOME. NODE_TEST_CONTEXT (set by `node --test`) gates it, so installs outside a Node test context are untouched; GSD_TEST_MODE is unusable, as several candidate files including the offender never set it. Homes are compared by FILESYSTEM IDENTITY (st_dev + st_ino), not by pathname: path.resolve() resolves neither symlinks nor case, and realpath returns a canonical pathname that two routes to one directory can still disagree on (bind mounts). Verified on macOS/APFS — HOME=/users/<name> made the strings differ while naming the same directory, and the lexical form ALLOWED a write into the physical real home. FAILS CLOSED: a pair is "different" only when both identify, or one is definitively absent (ENOENT/ENOTDIR) while the other identifies; every other errno is "cannot tell" and refuses. Only when neither home identifies is a marker consulted, and it carries the sandbox PATH and must equal the home in effect — a boolean checked first let an ambient or stale value disarm the guard. - helpers: promote sandboxHome() out of its two byte-identical private copies, which is also what makes them record the sandbox; the three withFakeHome() helpers record it too. The marker NAME is duplicated as a bare string rather than required from the compiled guard, keeping helpers.cjs's documented no-built-lib-at-import-time contract; a test pins the two together. - agent-descriptor-parity: sandbox HOME across the K1 loop. - helpers-process-isolation: #3156's canary asserts on <home>/.gsd only, and its `--cursor --local` spawn cannot reach `.agents` at all, so an assertion added there would pass with all confinement removed. Add a discriminating row — a `--codex --global` spawn against a seeded ambient home — which also asserts the runtime still declares the override. Its check is a sampled inventory (dir names + each SKILL.md), not a tree compare. - install-write-confinement: predicate rows through the deps seam, covering the symlinked HOME, ambient and stale markers, and each sameDirectory branch (both-identify, one-absent, neither-identifiable), plus wiring rows that drive the REAL entrypoints so deleting a guard call site is red. Verified: guard fires end-to-end against a real un-sandboxed HOME (exit 1, zero deletions); the case-variant fail-open reproduced on APFS before the fix and refuses after; K1 file 29/29 green with skills intact; mutation-tested — each of the three reachable call sites, lexical-only comparison, and treating an unknown errno as "absent" each take exactly one row red, with every mutation echoed back; the process-isolation row negative-controlled by reverting installerEnv to its pre-#3156 leak (16/0 -> 13/3); a full npm test leaves ~/.agents/skills at 71. Stated residual: the two descriptor-dependent writers have no wiring test, because no runtime declares a `home` override on those kinds and neither can be exercised without inventing a descriptor. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * chore(#3712): add changeset Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(#3712): let a sandbox nested inside the real home through the guard All six Windows shards of #3725 failed on legitimately sandboxed destinations. On Windows os.tmpdir() is %LOCALAPPDATA%\Temp — inside the user's home — so every sandbox a test creates is a descendant of the real home, and "does this land inside the real home?" answers yes for the safe case and the dangerous one alike. POSIX conceals this: /tmp and /var/folders both sit outside $HOME. Add the missing conjunct: a destination inside the real home is allowed only when it also sits beneath a HOME that was sandboxed away from the passwd home. Both halves are required — dropping the first re-admits a plain un-sandboxed install, and dropping the second decays into the "is HOME sandboxed?" check the module rejects, which a layout resolved before the sandbox walks straight through. Each is mutation-proven by a row that goes red without it. Also covers the two fail-closed branches of the new exemption, which survived mutation to `true` with the suite green, and avoids `<user>` in a docblock — the prompt-injection scanner reads it as a delimiter tag. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(#3712): close three writer/rollback gaps found reviewing the whole PR Cross-AI review of the full PR (not just the round's delta) surfaced three ways the guard could still be defeated: - The nested-sandbox exemption trusted the SPELLING of a destination. With HOME sandboxed to a directory inside the real home — legitimate on Windows — an aliased `.agents` (symlink, junction, subordinate bind mount) beneath it redirected an allowed path into the real home. Decide containment on the path the write RESOLVES to: walk up to the nearest existing ancestor, canonicalize, re-append the tail. - `migrateLegacyDevPreferencesToSkill` is a SIXTH writer that resolves a skills-kind `home` override. It creates rather than prunes, which is why it was missed, and `_runLegacyInstallMigrations` runs it before `installRuntimeArtifacts`' own assertion. Guarded, scoped to that kind. - Worst of the three: `bin/install.js` snapshots the resolved skills root before installing, and its outer catch rolls back by deleting and recreating every snapshotted `gsd-*` directory there. The guard's own throw landed in that catch, so refusing an un-sandboxed codex install provoked exactly the mutation the guard exists to prevent. Refusals are now marked and rethrown without rollback — nothing was written, so there is no partial install to undo. Every other error still rolls back. Also carries the sandbox marker into `installSpawnEnv`, so spawned installers are not refused on passwd-less CI images, and corrects three claims that no longer hold: "every writer" (six, and named), the unconditional "fails CLOSED" (the passwd-less marker branch is a deliberate weakening, and TOCTOU is out of scope), and the assertion that Windows os.tmpdir() is always %LOCALAPPDATA%\Temp (Node honors TEMP/TMP). Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs(#3712): name the guard's two limits instead of overclaiming Round-2 review found the prose had drifted ahead of the code. Corrected, with no behavior change: - The module still said FIVE writers; there are six, and the sixth is now named along with why it was missed (it creates rather than prunes) and why it carries its own assertion (it runs before the main one). - The canonicalization docblock listed subordinate bind mounts among the aliases it closes. It does not close them: a bind mount is not a link, so realpath keeps the mount-point spelling. `sameDirectory` already recorded that limit; the new helper now inherits it explicitly rather than contradicting it. Closing it needs mount-table introspection. - "FAILS CLOSED" was unqualified while the passwd-less marker branch is a deliberate weakening — with no passwd entry, nothing can contradict a marker naming the real home. - "Refuses BEFORE any write" was too broad: legacy install migrations run ahead of the layout-driven ones, which is exactly why the two rollbackInstallerMigrations() calls still execute before the rethrow. Only the codex skills-root rollback is skipped, and that is the only _codexPreConfigRollback() call site — applySurface is never called from bin/install.js and uninstall cannot reach it. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(#3712): sandbox HOME in the opencode-family home-override parity rows The last two Windows failures, and the same platform asymmetry in a different disguise. This row drives a skills-kind `home` override on purpose — precisely what the guard polices — but relied on the override temp dir happening to sit outside the real home. It does on POSIX (/tmp, /var/folders); on Windows os.tmpdir() is under %USERPROFILE%, so the guard correctly refused and only Windows went red. Declare the sandbox instead of depending on the platform: HOME becomes the override itself, which is the home the call writes under. This is the fix the guard's own message prescribes, applied to the test rather than to the guard. Both failing Windows shards fail on exactly these two rows and nothing else; every other shard is green. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(#3712): make sameDirectory answer NO when it cannot tell Review Major 1. sameDirectory()'s only caller is the passwd-less marker branch, which reads a `true` as permission to PROCEED: if (marker && sameDirectory(marker, osMod.homedir())) return; The fallthrough returned `true` whenever neither side identified — two absent paths, or two stats failing EACCES/EPERM/EIO on a locked-down host — on the reasoning that "cannot tell" should make the caller refuse. That reasoning was inverted with respect to this caller: it turned the passwd-less escape hatch into an unconditional bypass for any marker value at all, on precisely the hosts the fallback exists to serve. Only two things now answer yes: one resolved pathname, or two readable identities that match. Restoring the old fallthrough takes the new row red. Also from review: - Major 2 asked whether st_dev/st_ino discriminate directories on Windows, where Node derives them from BY_HANDLE_FILE_INFORMATION. The whole guard rests on that primitive, so assert it rather than argue it: a row comparing two distinct temp directories, and one directory reached by two spellings. It runs on every platform in the matrix, so Windows answers the question itself. - Minor 1: the refusal now names the real home it compared against, not just the destination it refused. That is the one fact needed to tell a true positive from a false one, and its absence is what made the Windows case a CI-log dig rather than a glance. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(#3712): refuse a HOME that merely spells the real home more widely Review round: one Blocker, four Minors, a Nit. N2 (the one with teeth) — a destination's ancestor chain is linear, so "inside the real home AND inside the effective HOME" admits two arrangements, not one. The intended `effectiveHome ⊂ realHome` is the Windows temp shape; `realHome ⊂ effectiveHome` — HOME at /Users, /home, C:\Users — is not a sandbox at all, it is the real home reached by a wider spelling, and it was exempting a stale destination pointing straight at ~/.agents. Third conjunct added; the docblock no longer claims two conditions suffice. Removing the conjunct reds the new row and nothing else. N4 — the migration guard resolved its OWN layout, and without capabilityRegistry, so a registry-dependent descriptor could make it vouch for a path the migration does not write: a guard reporting safe while the unsafe write proceeds. It now guards the destination already resolved by _resolveDevPreferencesSkillTarget, keyed on `installRoot !== targetDir` — which is exactly the condition under which a `home` override was declared, read off that same result. N1 — CONTEXT.md gains the Test Home Guard Module glossary entry that contributor-standards.md requires of a new Module. Not CI-enforced, so green CI was never evidence it was met. N3 — the docs/INVENTORY.md row was misfiled between install-fs-adapter and install-model-override-resolver; the table is alphabetical and the manifest already had it right. Moved, and its text now names six writers and the third conjunct. N5 — applySurface's signature docblock was two parameters stale; this PR added the second of them. N6 — the duplicated rollbackInstallerMigrations() adjacent to the new rethrow: two identical consecutive calls, not two phases. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(#3712): guard the sixth writer, and close two false-ALLOW paths Review round 3 (NEW-1, NEW-2) plus three defects Codex found in the whole-PR pass, each reproduced before it was fixed. NEW-1 — migrateLegacyDevPreferencesToSkill called the guard with no `deps`, so it bound real os/process.env and could not be wiring-tested the way the other three reachable writers were. It now takes the same optional `deps: { os?, env? }` tail parameter. The wiring block gains the missing fourth row, and a fifth pinning the ALLOW half; the test file's header docblock said "FIVE writers ... the three reachable today", contradicting the six/four statement this PR already put in src/test-home-guard.cts, CONTEXT.md, docs/INVENTORY.md and the changeset. Both directions of the guard's condition now fail a row when broken — previously neither did. NEW-2 — derivesFromSandboxedHome's docblock claimed "THREE conditions are required, and no two of them suffice". False for {2,3}: isInside is reflexive, so whenever conjunct 1 fires conjunct 2 already returns false on its own. Reworded as a fast path, which is what it is. Codex 1 (false ALLOW) — on a host with no readable passwd entry the marker branch returned as soon as the marker matched the effective HOME. That attests a caller sandboxed HOME and says nothing about where an already-resolved destination points, so a layout captured before sandboxHome() — still naming the real ~/.agents — was waved straight through: the same stale-layout shape the primary branch refuses by design. The marker must now identify AND contain every destination. Codex 2 (false ALLOW) — `installRoot !== targetDir` was the stand-in for "the skills kind declared a home override". The two are not equivalent: the inequality is false when the override resolves onto targetDir itself, which is exactly a configDir of $HOME/.agents. The guard was skipped and SKILL.md written into the real home under a test runner. _resolveDevPreferencesSkillTarget now reports hasHomeOverride off the same resolution instead of inferring it from two paths. Codex 3 (prose) — the shared refusal message claimed every guarded writer prunes; the migrate writer only creates. The changeset headline claimed in-process installer calls can no longer reach the real home, which is wider than the guard: writeNonClaudeDefaults still writes ~/.gsd/defaults.json through os.homedir(). INVENTORY's and CONTEXT's fail-closed sentences omitted sameDirectory's pathname-equality shortcut. All four narrowed to what the code does. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(#3712): let the sandbox marker follow an overridden HOME Found by Codex in the whole-PR pass. installSpawnEnv spreads `overrides` last so an explicit HOME wins — deliberate, and its docblock tells callers needing per-spawn isolation to pass their own { HOME, USERPROFILE }. But the #3712 marker was set before that spread, so such a caller got HOME=<theirs> and marker=<helper default>. On a host with no readable passwd entry the guard compares the two and refuses a legitimately sandboxed spawn — tests/install.test.cjs:7143 and install-shared.cjs's own runInstaller both take that path. The marker is now derived from the final HOME unless the caller supplied one explicitly. The contract test asserted HOME after an override but not the marker, which is why it stayed green. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs(#3712): name the shipped guard condition, not the deleted one Review round 4 of #3725. Two artifacts this PR adds still described `target.installRoot !== targetDir` in the PRESENT tense as the live guard condition on `migrateLegacyDevPreferencesToSkill`. The shipped condition is `runtime && target.hasHomeOverride` (src/install-engine.cts:510). This is not ordinary doc drift. The named condition is the exact false-ALLOW the previous round closed: a `home` override resolving onto `targetDir` — a configDir of `$HOME/.agents`, which is where codex's override points — makes the inequality FALSE while the override is declared, so the guard was skipped. A maintainer reading CONTEXT.md:290 as authoritative would believe the guard still skips that case. - tests/install-write-confinement.test.cjs — the ALLOW-half row's comment. Its "teeth" rationale is unchanged and still correct as written. - CONTEXT.md:290 — the Test Home Guard Module glossary entry, a documented PR gate. Now states the condition and names the inequality only as what it is NOT, with the reason. The three surviving mentions of the inequality are all past-tense or negated (src/install-engine.cts:448, :508 and the sibling test comment at :3698) and are correct as they stand. Verified: `npm run lint:ci` exit 0; full `npm test` 31327 tests / 31312 pass / 0 fail / 14 skipped, run with TMPDIR unset. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(#3712): canonicalization fails closed, matching identify's errno split Codex full-PR review of #3725, run against the round-4 head. `resolveThroughLinks` caught EVERY realpathSync error and fell back to `path.resolve(dest)` — the lexical spelling. That inverts the function's own purpose. An aliased `<sandbox>/.agents` that cannot be canonicalized keeps its sandbox spelling, satisfies the nested-sandbox exemption at :227, and the write is ALLOWED into the real home — the exact escape this walk exists to close. The module documents that it fails CLOSED with ONE named exception (the marker branch); this was a second, unnamed one. Split by errno, and deliberately by the SAME split `identify` already draws rather than a second policy in one module — both answer "does this path exist as named?", so they must not disagree: ENOENT / ENOTDIR -> walk up. The ordinary case: a fresh install resolves a destination nothing has created yet, so realpath fails on the leaf and on every not-yet-created ancestor. Refusing here rejects every install. anything else (EACCES, EPERM, ELOOP, EIO) -> refuse. The component exists but cannot be resolved, so the guard cannot tell where the write lands. Three rows in the predicate block, beside the other aliasing rows: - a symlink CYCLE in the destination path (ELOOP) -> REFUSE - a destination that does not exist yet (ENOENT) -> ALLOW - a component behind a regular file (ENOTDIR) -> ALLOW Teeth checked against the artifact the test loads, not the source: reverting the condition to the swallow-everything shape in the compiled test-home-guard.cjs turns row 1 — and only row 1 — red. The ENOTDIR row caught a stale build during development, which is the point of asserting on the compiled file. CONTEXT.md and the resolveThroughLinks docblock both record the new behaviour, so this does not repeat the prose-vs-code drift the round-4 finding was about. The changeset's existing scope sentence now bounds "six writers" to the `installRuntimeArtifacts` call tree and names `cmdGenerateDevPreferences` — which resolves the same codex `home` override through `getGlobalSkillsBase` and writes SKILL.md beneath it unguarded. It has no in-process caller today (its only direct require-and-call is a spawnSync with HOME sandboxed), so it is latent rather than live, and whether it belongs in this PR is raised with the maintainer rather than decided here. Verified: `npm run lint:ci` exit 0; full `npm test` 31330 tests / 31315 pass / 0 fail / 14 skipped, TMPDIR unset. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5 <noreply@anthropic.com>	2026-08-23 18:27:02 -04:00
Tom Boucher	3ab0007164	enh(#2875): materialization primitives — durable user-artifact staging and descriptor-authoritative agents (#3600) ... * fix(#2875): stage user artifacts durably across install wipes (#1874-F19) preserveUserArtifacts held user files only in an in-memory Map across the wipe, so any process death between preserve and restore lost them outright. Seven call sites, not the four the issue records. Three of them never called the helper at all - they open-coded the same read/wipe/write - so searching for callers under-counted by construction; the extra sites were found by sweeping for the pattern instead. The worst is the mainline install path, where the crash window spans the entire gsd-core tree copy rather than a single rmSync. Adds src/user-artifact-staging.cts: durable on-disk staging with a record written after the copies land as the commit point, plus recovery of orphaned batches on the next run - without recovery the staged bytes survive but the user's file is still gone, which would pass its own test while delivering nothing. Routes copyPreservingSymlink through installFs() so staging cannot bypass the install fs seam, and reunites its symlink-safety docblock with the function it documents. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(#2875): amend ADR-3574 with four claims disproved by implementation Implementing Phase 6 disproved four statements the ADR rests on. The central decision - no single materializer - is unaffected and stands. Corrected: decision 3 was already satisfied, so nothing was extracted; the agents-bypass runtime set omitted claude, kilo and opencode, and closing it needed three new pieces of descriptor contract rather than proceeding on its own terms; three of the four blockers the layout comment names were already stale; and F19 is seven call sites, not four. Records the generalizable lesson: the defect is the pattern of holding user data in memory across a wipe, not the helper, so searching for callers of the helper under-counts by construction. Also resolves the ADR's open question on USER_OWNED_ARTIFACTS membership, and notes that copyPreservingSymlink needed routing through the install fs seam before it could be reused. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(#2875): close dangling-symlink blind spot and harden staging recovery An adversarial review found the F19 staging work shipped red and unsafe. Root cause, shared by two arbitrary-write findings: hasExistingSymlinkBetween missed dangling symlinks in both its root check and its per-segment walk, because it probed with existsSync, which is false for a link whose target does not exist. Fixing only the new module would have reused a guard that was itself blind. This guard protects the whole install tree. Recovery no longer throws: it degrades per entry and per file, so one bad batch cannot block the others. Previously an unrecoverable entry propagated out of the first statement of install and uninstall, before the cleanup that would have removed it - wedging the installer permanently. Partial fs adapters now throw on any omitted method instead of silently reaching the real filesystem, closing the trap that let a test poison list pass while real IO happened. Staged names must be flat, recovery refuses a dangling destination symlink, and a batch whose recovery genuinely failed is no longer swept - it was discarding the only durable copy of the file it had just failed to restore. Replaces three tests that could not fail, including the one labelled negative proof. Known limitation, documented not closed: concurrent installs sharing a staging key can still lose a batch. A real fix needs a cross-process lock. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * enh(#2875): make the descriptor authoritative for the agents kind Deletes the inline agent-staging loop in bin/install.js and the _DESCRIPTOR_AGENTS_RUNTIMES set, so every runtime materializes agents from its capability descriptor instead of an inline hostBehaviors dispatch. Closing it needed three pieces of contract the descriptor pipeline never had, all reducible to one missing input - per-agent resolution context: a frontmatter-extensions step for claude's effort and disallowedTools, per-agent model-override resolution for kilo and opencode, and a named branding converter for hermes, whose rewrite data was already declared. Seven runtimes were on the loop, not the six the design recorded - kimi-code was found by a golden fixture, not by analysis. claude-local and kimi-code both silently lost their agents mid-change; the fixtures caught both and the cause was fixed rather than the fixtures regenerated. A parity harness gates the migration: both pipelines over identical inputs, byte-identical output including filenames, per runtime. It is demonstrated red before being trusted. Surface and install paths converge for all seven, which also fixes surface previously writing no agents for these runtimes. Codex's config.toml strip stays put - it mutates host config, which no descriptor kind models. Also routes install-model-override-resolver and install-effort-resolver through the install fs seam. Both leaked real filesystem IO from the install call tree; the stricter adapter is what exposed them. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(#2875): record the agents-descriptor migration and correct the ADR count The _DESCRIPTOR_AGENTS_RUNTIMES allow-list no longer exists, so the host integration guide told readers to join a set that is gone. Replaces that with what is now true - declare an agents entry and it installs, on the surface path as well as install - and points anyone needing a per-agent transform at the three extension points rather than at a new inline branch. Corrects the ADR amendment: seven runtimes were on the inline loop, not six. kimi-code was found by a golden fixture going red, not by reading. That is the third short count this phase, all from enumerating by symbol or set membership when the thing that matters is a behavior. Adds the Changed changeset for the surface-path convergence. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(#2875): amend ADR-2866 - claude global always wrote agents on disk The claude row's global=[skills] described what capability.json declared, not what the installer wrote. bin/install.js's inline agent-staging loop was never scope-gated and never consulted the descriptor, so a claude --global install has always written agents/gsd-*.md. Phase 6 closes the gap by deleting that loop and declaring agents on claude's descriptor at global scope. On-disk bytes are unchanged - the golden fixtures did not move, which is the evidence that the descriptor, not the installer, was incomplete. #2218 is unaffected: agents are not trigger-bearing, so the wider row does not introduce a new shadowing case. Records the warning that an incomplete descriptor is invisible while a second code path silently does its work, and only surfaces when the two are forced into agreement. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(#2875): close review findings across staging, agents and the parity harness Two independent reviews of this branch found defects the local gates missed. Security: a dangling symlink at a migration destination allowed writing outside configDir - the same class this change claimed to close, missed at the terminal write of the flow being added. The staging-root resolver threw as the first statement of install and uninstall, so a hostile symlink bricked both, and symlinked-configDir users lost uninstall as well as install; it now degrades instead of aborting. Recovery gained a source-side symlink check and now refuses a relative destDir, which resolved against cwd. Converter dispatch gained a runtime allowlist - lint-time validation stopped mattering once this branch promoted that dispatch from the surface path to real installs. Correctness: claude --local --minimal exited 1 because the minimal profile legitimately yields zero agents and the new path treated that as a failure. cline --local silently lost its agents - its descriptor declared none while the deleted loop wrote them unconditionally. The agents prune was widened to any gsd-* entry and destroyed user files it never owned. The parity harness, on which the migration's safety argument rested, drove a synthetic registry and never byte-compared the shipped descriptors; two of its trap rows could not fail. It now drives the real registry across 13 runtime-scope rows including kimi-code and cline-local, and its red-proof is demonstrated by corrupting a live capability.json. Three goldens that had encoded the cline regression as expected behavior were corrected. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(#2875): close findings from both mandated review engines /security-review found the staging source-side walk honouring GSD_ALLOW_SYMLINKED_DEST, an opt-in documented as relaxing only the write destination. A symlinked files/ component dereferenced because copyPreservingSymlink lstats the leaf only, so an intermediate link is followed. The source walk no longer honours the opt-in; the destination check still does. /code-review spec axis found this branch had reintroduced its own bug: migrateLegacyDevPreferencesToSkill's new symlink refusal threw unguarded after the legacy dir was wiped and before the staged batch was restored, so a planted symlink bricked uninstall permanently and orphaned the batch. Refusal kept, abort removed. kimi-code local silently lost its agents, the same class as the cline bug, and the parity harness recorded that exclusion as intentional - the third test in this branch to pin a regression as correct. --minimal now creates an empty agents/ dir that never existed. Behaviour restored rather than softening the changeset, so its byte-identical claim stays true. Standards axis: try/finally removed from twelve test bodies, fast-check properties added for parseOwnerPid, boundary coverage at the grace window and the ancestor-probe depth, a parity assertion for the staging-root helper duplicated across two files, and the 8-deep config walk deduplicated. Records 60-review.json with every finding and disposition from five passes, including the smells left unfixed and why. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(#2875): prune stale agents unconditionally in minimal mode The previous round stopped an empty agents/ directory being created when the resolved profile yields no agents. That was implemented by skipping the agents kind entirely, which also skipped its stale-agent prune - so a full to minimal downgrade left stale gsd-* agents behind. The deleted inline loop pruned unconditionally and only skipped writing. Those are three separate conditions, not one: prune always, write only when there is something to write, create the directory only when writing. Both call sites now run _removeGsdEntries before the empty-staged early exit. The symlink-escape guard moved with it, since the prune also touches dest. Codex .toml agents and the config.toml stanzas are cleaned again, and user-owned agents are still preserved. The agents/ directory is left in place after a prune empties it, matching every sibling kind - none of them remove the destination directory itself. Golden fixtures confirmed byte-identical: the prune is a no-op on a fresh install, so fixture generation is unaffected. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(#2875): document interrupted-install recovery for user-owned files The durable-staging fix is invisible to the user it protects. Someone whose install died mid-flight has no way to know USER-PROFILE.md was staged before the delete, that the next run restores it, or that recovery happens at the start of that run rather than in the background. Written as the task the user has - finish the interrupted command - rather than as a description of the mechanism, and states what it will not do: overwrite a file already present, or touch staging belonging to another install still running. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * chore(#2875): backfill changeset pr number Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * test(#2875): assert the J8 model override without building a regex CodeQL flagged incomplete string escaping: the assertion interpolated the override value into a RegExp while escaping only forward slashes, which is meaningless in a constructor, leaving real metacharacters unescaped. The failure direction was the dangerous one - a metacharacter would have made the match more permissive, so the row would pass when it should fail. That matters here because J8 exists precisely because an earlier revision was a tautology; the rewrite reintroduced a different way for the same assertion to stop discriminating. Replaced with a line-wise exact match, so no regex is constructed at all. Swept the other test files this branch adds; no sibling instances. lint:ci passed on the original - lint-no-adhoc-regex-escape matches a full metachar-escape copy, so a single slash replace slipped under it. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> --------- Co-authored-by: sim <sim@local> Co-authored-by: Claude Opus 5 <noreply@anthropic.com>	2026-08-17 17:25:53 -04:00