rvlib-shipkit 0.35.4 → 0.35.5

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.35.5
+
+- **The `TaskDef.inputs` doc comment stated only half the safety rule.** It said undeclared means never cached, so forgetting costs speed and never correctness, which is true for forgetting a whole task and false for the mistake that actually ships a false green: a list MISSING a path the command reads. The key cannot move when that path changes, so the answer replays over a tree it no longer describes. Observed twice in the field in one day. The comment now carries the asymmetry, names `['.']` as the declaration that cannot under declare, and says that a task carries no code closure, so the script it runs belongs in `inputs` too.
+- **`shipkit release` scopes its dirt check exactly like `shipkit bump`.** `bump` examined the released unit plus every package.json and lockfile a version commit can touch; `release` examined the WHOLE worktree, refused, and then named `shipkit release` as the fix, which refuses identically. Several agents share one checkout here, so a neighbour editing an unrelated package was enough to wedge a release with no way forward that the message described. The reason to refuse at all is unchanged and still applies inside the scope: `npm publish` packs the WORKING TREE rather than the commit, so a half written file inside the unit ships under a tag that describes something else. Dirt in another unit reaches neither the tarball nor the tag, and the refusal now says what it examined.
+
 ## 0.35.4
 
 - **The imports refusal did not follow tsconfig `extends`, so a correctly configured repo went red and was told to add a key it already had.** Inheriting `paths` from a base config is the more common way to carry them, and only `references` was handled. `extends` is now followed (relative and node-resolved, chains and cycles included), and a mapping counts only when its TARGET is on disk: `"src/*": ["./packages/core/src/*"]` maps the prefix and resolves nothing. A package prefix is no longer accepted on the package DIRECTORY existing either, since a stale installed copy missing the file is the same false green one level up. `baseUrl` is no longer proof at all: tsc follows one, but rollup, esbuild and vite do not resolve a bare specifier through it, and the field failure this guard exists for was a rollup one. A multi-segment root (`packages/core`) is named as itself rather than as `packages`.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "0.35.4",
+    "version": "0.35.5",
     "description": "All-in-one repo companion: ci gate (task DAG), auto-discovered health checks, release-contract fulfillness, asks queue, md-wiki tools, asset atelier, live tui",
     "license": "MIT",
     "type": "module",

package/src/core/task-runner.ts

@@ -32,8 +32,14 @@ export type TaskDef = {
     timeoutMs?: number
     /** CONTENT population: the repo-relative paths this task reads. Declaring
      *  them is what makes the task keyable (ledger/git-key.ts). Undeclared is
-     *  the DEFAULT and means never cached, so forgetting costs speed and never
-     *  correctness. Declaring both this and `ttl` is a registration failure. */
+     *  the DEFAULT and means never cached, so forgetting a whole task costs
+     *  speed and never correctness. A list MISSING a path the command reads is
+     *  the one that costs correctness: the key cannot move when that path
+     *  changes, so the answer replays over a tree it no longer describes. Over
+     *  declaring costs a re-run, under declaring is a false green, and `['.']`
+     *  is the whole work tree and cannot under declare. A task carries no code
+     *  closure, so the script it runs belongs in here too.
+     *  Declaring both this and `ttl` is a registration failure. */
     inputs?: string[]
     /** WORLD population: this task reads the network, a keychain, $PATH or the
      *  clock, so nothing on disk describes its answer and a clean pass is

package/src/release/run-release.ts

@@ -11,6 +11,7 @@ import { join } from 'path'
 import { runCi } from '../core/run-ci.ts'
 import { extractChangelogSection } from './changelog.ts'
 import { deriveRemote, dirtyPaths, git, remoteTagState, tagExistsLocally, type RemoteTagState } from './git-facts.ts'
+import { releaseScope } from './release-scope.ts'
 import { npmPublishArgv, unitBlockers } from './unit-gate.ts'
 import { formatUnitError, resolveUnits, unitById, type ReleaseUnit } from './units.ts'
 import type { RepoConfig } from '../repo-config.ts'
@@ -172,9 +173,23 @@ export async function releaseUnit(root: string, config: RepoConfig, unit: Releas
     if (cur.code !== 0) blockers.push('not a git repository')
     else if (cur.out !== branch) blockers.push(`releases ship from '${branch}', HEAD is on '${cur.out}'`)
 
-    const dirty = dirtyPaths(root, config)
-    if (dirty !== '' && o.allowDirty !== true)
-        blockers.push(`working tree not clean (--allow-dirty overrides):\n${dirty.split('\n').slice(0, 10).join('\n')}`)
+    // scoped exactly like `bump`, and for the same reason: `npm publish` packs
+    // the WORKING TREE rather than the commit, so dirt INSIDE what ships can
+    // put a half written file under a tag that describes something else. Dirt
+    // in another unit reaches neither this tarball nor this tag. Checking the
+    // whole tree here made `release` refuse what `bump` allows, and then name
+    // `shipkit release` as the fix, which refuses identically: several agents
+    // share this checkout, so a neighbour editing an unrelated package was
+    // enough to wedge a release with no way forward that the message named.
+    // the sibling units matter to the SCOPE: a version write rewrites the
+    // rvlib range in every dependent's package.json, so those paths are inside
+    // this release even though they are outside this unit
+    const scope = releaseScope(root, resolveUnits(root, config).units, [unit])
+    const dirty = dirtyPaths(root, config, scope.specs ?? undefined)
+    if (dirty !== '' && o.allowDirty !== true) {
+        blockers.push(`uncommitted changes in ${scope.describe} (--allow-dirty overrides):\n${dirty.split('\n').slice(0, 10).join('\n')}`)
+        if (scope.specs != null) blockers.push('dirt elsewhere in the worktree is deliberately ignored, it cannot reach this tarball or this tag')
+    }
     if (o.skipUnitGate !== true) blockers.push(...unitBlockers(root, config, unit))
 
     let alreadyPublished = false