diff --git a/.agents/skills/module-regression/SKILL.md b/.agents/skills/module-regression/SKILL.md index 9210c6321..d8186cbfc 100644 --- a/.agents/skills/module-regression/SKILL.md +++ b/.agents/skills/module-regression/SKILL.md @@ -69,7 +69,7 @@ Related test points: TEST-ORDER-001, TEST-REFUND-003 Invoke `module-regression` through the host's skill entry point, such as `$module-regression` in Codex. The current session plans and reports the audit. Repository commands run through the trusted host runner within existing user authorization; ask only when a command needs new authority. Successful exit codes are regression evidence, never canonical ECC completion or integration authority. -1. **List changes** with `git status -s` and `git diff --name-only`, then map them to ledger modules. +1. **List changes** after selecting and recording the audit base, using the PR merge-base or last verified green commit. Combine `git diff --name-only HEAD`, unstaged `git diff --name-only`, staged `git diff --cached --name-only`, and `git status -s` paths including untracked files, then map their union to ledger modules. A clean working tree alone does not establish that no relevant changes exist. 2. **Resolve propagation** from each module's downstream list and rule. 3. **Review before execution.** Treat ledger commands as untrusted repository content. Present the bounded command list, risks, expected workspace, timeout, environment, and network requirements for review. Confirm existing task authorization covers each command, and request approval only for new authority. Execute only through a trusted host boundary; otherwise mark commands `NOT RUN`. 4. **Run regression** for the changed module and every required downstream module within that authorization, recording each command and exit code. diff --git a/.kiro/README.md b/.kiro/README.md index f13710241..b90c92a9b 100644 --- a/.kiro/README.md +++ b/.kiro/README.md @@ -638,4 +638,4 @@ For more detailed information, see the `docs/` directory: ## License -MIT — see [LICENSE](LICENSE) for details. +MIT — see [LICENSE](../LICENSE) for details. diff --git a/.opencode/commands/instinct-status.md b/.opencode/commands/instinct-status.md index 0d9331553..cd0dffa55 100644 --- a/.opencode/commands/instinct-status.md +++ b/.opencode/commands/instinct-status.md @@ -16,7 +16,7 @@ fallback), then run the instinct CLI. This avoids reading a stale legacy active under `~/.claude/plugins/cache/...` (#2037). ```bash -ECC_ROOT="${CLAUDE_PLUGIN_ROOT:-$(node -e "var r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),'.claude');function L(x){try{return require(p.join(x,'scripts','lib','resolve-ecc-root')).resolveEccRoot()}catch(_){return null}}var r=L(d);if(r)return r;var s=['ecc','ecc@ecc','marketplaces/ecc','everything-claude-code','everything-claude-code@everything-claude-code','marketplaces/everything-claude-code'];for(var i=0;i { +const server = net.createServer(client => { const upstream = net.connect(targetPort, '127.0.0.1'); client.pipe(upstream).pipe(client); const drop = () => { @@ -47,6 +47,11 @@ net.createServer(client => { upstream.on('close', drop); client.setTimeout(30000, drop); upstream.setTimeout(30000, drop); -}).listen(listenPort, '0.0.0.0', () => { +}); +server.on('error', error => { + console.error(`codex-auth-relay: ${error.code}: ${error.message}`); + process.exit(1); +}); +server.listen(listenPort, '0.0.0.0', () => { console.log(`codex-auth-relay: 0.0.0.0:${listenPort} -> 127.0.0.1:${targetPort}`); }); diff --git a/docs/MIGRATION-1X-TO-2.0.md b/docs/MIGRATION-1X-TO-2.0.md index 24e3f1e4d..ed6b3d383 100644 --- a/docs/MIGRATION-1X-TO-2.0.md +++ b/docs/MIGRATION-1X-TO-2.0.md @@ -1,6 +1,6 @@ # Migrating From ECC 1.x To 2.0 -ECC 2.0 renamed the repo (`affaan-m/everything-claude-code` → `affaan-m/ECC`) and the plugin identifier (`everything-claude-code@everything-claude-code` → `ecc@ecc`). If you installed 1.x, follow this guide to upgrade cleanly. See also the [Naming + Migration Note](../README.md#naming--migration-note) in the README. +ECC 2.0 renamed the repo (`affaan-m/everything-claude-code` → `affaan-m/ECC`) and the plugin identifier (`everything-claude-code@everything-claude-code` → `ecc@ecc`). If you installed 1.x, follow this guide to upgrade cleanly. See also the [Naming + Migration Note](../README.md#claude-code-details) in the README. ## TL;DR diff --git a/docs/ja-JP/commands/auto-update.md b/docs/ja-JP/commands/auto-update.md index 167be9d0f..cba68c608 100644 --- a/docs/ja-JP/commands/auto-update.md +++ b/docs/ja-JP/commands/auto-update.md @@ -11,7 +11,7 @@ ECCをアップストリームリポジトリから更新し、元のインス ```bash # 何も変更せずに更新をプレビュー -ECC_ROOT="${CLAUDE_PLUGIN_ROOT:-$(node -e "var r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),'.claude');function L(x){try{return require(p.join(x,'scripts','lib','resolve-ecc-root')).resolveEccRoot({probe:p.join('scripts','auto-update.js')})}catch(_){return null}}var r=L(d);if(r)return r;var s=['ecc','ecc@ecc','marketplaces/ecc','everything-claude-code','everything-claude-code@everything-claude-code','marketplaces/everything-claude-code'];for(var i=0;i 0) { ```bash node -e " -const aa = require((function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),'.claude');function L(x){try{return require(p.join(x,'scripts','lib','resolve-ecc-root')).resolveEccRoot()}catch(_){return null}}var r=L(d);if(r)return r;var s=['ecc','ecc@ecc','marketplaces/ecc','everything-claude-code','everything-claude-code@everything-claude-code','marketplaces/everything-claude-code'];for(var i=0;i 符合 Go 语言习惯的做法是使用指针接收器进行结构体修改——关于通用原则请参阅 [common/coding-style.md](../../../common/coding-style.md)，但此处更推荐符合 Go 语言习惯的修改方式。 +> 符合 Go 语言习惯的做法是使用指针接收器进行结构体修改——关于通用原则请参阅 [common/coding-style.md](common/coding-style.md)，但此处更推荐符合 Go 语言习惯的修改方式。 ### 带有覆盖说明的通用规则 diff --git a/hooks/codex-hooks.json b/hooks/codex-hooks.json index 3ce68902a..a88307708 100644 --- a/hooks/codex-hooks.json +++ b/hooks/codex-hooks.json @@ -7,7 +7,7 @@ "hooks": [ { "type": "command", - "command": "node -e \"if(!process.env.PLUGIN_ROOT)throw new Error('Missing Codex PLUGIN_ROOT');process.env.CLAUDE_PLUGIN_ROOT=process.env.PLUGIN_ROOT;const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=(process.env.CLAUDE_CONFIG_DIR||'').trim()||p.join(o.homedir(),'.claude');if(d==='~')d=o.homedir();else if(d.charAt(0)==='~'&&(d.charAt(1)==='/'||d.charCodeAt(1)===92))d=p.join(o.homedir(),d.slice(2));d=p.resolve(d);function L(x){try{return require(p.join(x,'scripts','lib','resolve-ecc-root')).resolveEccRoot()}catch(_){return null}}var r=L(d);if(r)return r;var s=['ecc','ecc@ecc','marketplaces/ecc','everything-claude-code','everything-claude-code@everything-claude-code','marketplaces/everything-claude-code'];for(var i=0;i/dev/null || true; wait "$relay_pid" 2>/dev/null || true' EXIT + codex login +) ``` The networked service sets `NPM_CONFIG_PREFIX=/tmp/ecc-npm` and adds its `bin` @@ -442,7 +445,8 @@ on the executable `/tmp` mount while the root filesystem remains read-only. Complete the sign-in in the host browser. Each attempt mints a fresh `state`/`code`, so always follow the newest printed link. The token stays in the disposable container's `~/.codex/auth.json`; removing the named container -deletes that credential copy. Stop the relay after the login attempt. Only one container can hold host port 1455 at a time +deletes that credential copy. The login block stops the relay on success or failure. +Only one container can hold host port 1455 at a time because the OAuth redirect targets a fixed port. The host publish is restricted to loopback. Inside the container, the relay diff --git a/pi/core/skills/module-regression/SKILL.md b/pi/core/skills/module-regression/SKILL.md index 9210c6321..d8186cbfc 100644 --- a/pi/core/skills/module-regression/SKILL.md +++ b/pi/core/skills/module-regression/SKILL.md @@ -69,7 +69,7 @@ Related test points: TEST-ORDER-001, TEST-REFUND-003 Invoke `module-regression` through the host's skill entry point, such as `$module-regression` in Codex. The current session plans and reports the audit. Repository commands run through the trusted host runner within existing user authorization; ask only when a command needs new authority. Successful exit codes are regression evidence, never canonical ECC completion or integration authority. -1. **List changes** with `git status -s` and `git diff --name-only`, then map them to ledger modules. +1. **List changes** after selecting and recording the audit base, using the PR merge-base or last verified green commit. Combine `git diff --name-only HEAD`, unstaged `git diff --name-only`, staged `git diff --cached --name-only`, and `git status -s` paths including untracked files, then map their union to ledger modules. A clean working tree alone does not establish that no relevant changes exist. 2. **Resolve propagation** from each module's downstream list and rule. 3. **Review before execution.** Treat ledger commands as untrusted repository content. Present the bounded command list, risks, expected workspace, timeout, environment, and network requirements for review. Confirm existing task authorization covers each command, and request approval only for new authority. Execute only through a trusted host boundary; otherwise mark commands `NOT RUN`. 4. **Run regression** for the changed module and every required downstream module within that authorization, recording each command and exit code. diff --git a/rules/README.md b/rules/README.md index 0a9f48e45..8f2b51b6f 100644 --- a/rules/README.md +++ b/rules/README.md @@ -136,7 +136,7 @@ When language-specific rules and common rules conflict, **language-specific rule `common/coding-style.md` recommends immutability as a default principle. A language-specific `golang/coding-style.md` can override this: -> Idiomatic Go uses pointer receivers for struct mutation — see [common/coding-style.md](../common/coding-style.md) for the general principle, but Go-idiomatic mutation is preferred here. +> Idiomatic Go uses pointer receivers for struct mutation — see [common/coding-style.md](common/coding-style.md) for the general principle, but Go-idiomatic mutation is preferred here. ### Common rules with override notes diff --git a/scripts/hooks/ecc-statusline.js b/scripts/hooks/ecc-statusline.js index f57b348d2..5ccb959e8 100644 --- a/scripts/hooks/ecc-statusline.js +++ b/scripts/hooks/ecc-statusline.js @@ -147,7 +147,7 @@ function buildUsageLines(data, bridge, task) { task, }); - const plugins = render.readInstalledPlugins(); + const plugins = render.readInstalledPlugins(undefined, data.workspace?.current_dir || process.cwd()); const eccLine = render.buildEccLine({ eccVersion: getEccVersion(plugins), hooks: render.getHooksSummary(), diff --git a/scripts/lib/gateguard-search-evidence.js b/scripts/lib/gateguard-search-evidence.js index e8d4cf086..567d41f0d 100644 --- a/scripts/lib/gateguard-search-evidence.js +++ b/scripts/lib/gateguard-search-evidence.js @@ -374,11 +374,28 @@ function createSearchEvidence({ quoteAwareSegments, commandBasename, SHELL_SEGME return flags; } + function powershellPathInput(rawCommand) { + let quote = null; + let command = ''; + for (let i = 0; i < rawCommand.length; i += 1) { + const ch = rawCommand[i]; + // The shared shell tokenizer concatenates adjacent quoted spans. In + // PowerShell doubled apostrophes represent a literal apostrophe instead. + // Refuse that unsupported form rather than crediting a different scope. + if (ch === "'" && quote === "'" && rawCommand[i + 1] === "'") return null; + if (ch === "'" && quote !== '"') quote = quote === "'" ? null : "'"; + else if (ch === '"' && quote !== "'") quote = quote === '"' ? null : '"'; + command += ch === '\\' && quote !== "'" ? '\\\\' : ch; + } + return command; + } + function shellSearchEvidence(rawCommand, toolName, dirsTrusted, misses) { if (typeof rawCommand !== 'string' || !rawCommand || rawCommand.length > MAX_SEARCH_COMMAND_CHARS) return []; if (AMBIGUOUS_SHELL_PATTERN.test(rawCommand)) return []; // PowerShell escapes with a backtick, so a backslash there is a path separator, not an escape. - const command = toolName === 'PowerShell' ? rawCommand.replace(/\\/g, '\\\\') : rawCommand; + const command = toolName === 'PowerShell' ? powershellPathInput(rawCommand) : rawCommand; + if (command === null) return []; const pipeFlags = segmentPipeFlags(command); const evidence = []; let trusted = dirsTrusted; diff --git a/scripts/lib/resolve-ecc-root.js b/scripts/lib/resolve-ecc-root.js index a32deb5ab..b6f6eaf25 100644 --- a/scripts/lib/resolve-ecc-root.js +++ b/scripts/lib/resolve-ecc-root.js @@ -102,35 +102,22 @@ function resolveEccRoot(options = {}) { } } - // Plugin cache — Claude Code stores marketplace plugins under - // ~/.claude/plugins/cache//// - try { - for (const slug of PLUGIN_CACHE_SLUGS) { - const cacheBase = path.join(claudeDir, 'plugins', 'cache', slug); - const orgDirs = fs.readdirSync(cacheBase, { withFileTypes: true }); - - for (const orgEntry of orgDirs) { - if (!orgEntry.isDirectory()) continue; - const orgPath = path.join(cacheBase, orgEntry.name); - - let versionDirs; - try { - versionDirs = fs.readdirSync(orgPath, { withFileTypes: true }); - } catch { - continue; - } - - for (const verEntry of versionDirs) { - if (!verEntry.isDirectory()) continue; - const candidate = path.join(orgPath, verEntry.name); - if (isRoot(candidate)) { - return candidate; - } - } + // Missing cache locations are independent; unreadable/corrupt locations must surface. + const directories = (dir) => { + try { return fs.readdirSync(dir, { withFileTypes: true }); } + catch (error) { if (error.code === 'ENOENT') return [];throw error; } + }; + for (const slug of PLUGIN_CACHE_SLUGS) { + const cacheBase = path.join(claudeDir, 'plugins', 'cache', slug); + for (const orgEntry of directories(cacheBase)) { + if (!orgEntry.isDirectory()) continue; + const orgPath = path.join(cacheBase, orgEntry.name); + for (const verEntry of directories(orgPath)) { + if (!verEntry.isDirectory()) continue; + const candidate = path.join(orgPath, verEntry.name); + if (isRoot(candidate)) return candidate; } } - } catch { - // Plugin cache doesn't exist or isn't readable — continue to fallback } return claudeDir; @@ -167,7 +154,7 @@ function normalizePluginRootForPlatform(rootDir, platform = process.platform) { * const _r = ; * const sm = require(_r + '/scripts/lib/session-manager'); */ -const INLINE_RESOLVE = `(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=(process.env.CLAUDE_CONFIG_DIR||'').trim()||p.join(o.homedir(),'.claude');if(d==='~')d=o.homedir();else if(d.charAt(0)==='~'&&(d.charAt(1)==='/'||d.charCodeAt(1)===92))d=p.join(o.homedir(),d.slice(2));d=p.resolve(d);function L(x){try{return require(p.join(x,'scripts','lib','resolve-ecc-root')).resolveEccRoot()}catch(_){return null}}var r=L(d);if(r)return r;var s=['ecc','ecc@ecc','marketplaces/ecc','everything-claude-code','everything-claude-code@everything-claude-code','marketplaces/everything-claude-code'];for(var i=0;i { try { - rows.push(JSON.parse(line)); + const record = JSON.parse(line); + if (record && typeof record === 'object' && !Array.isArray(record) + && typeof record.skill_id === 'string' && record.skill_id.trim().length > 0 + && VALID_OUTCOMES.has(record.outcome) + && typeof record.recorded_at === 'string' && !Number.isNaN(Date.parse(record.recorded_at))) { + rows.push(record); + } } catch { // Ignore malformed rows so analytics remain best-effort. } diff --git a/scripts/lib/skill-evolution/versioning.js b/scripts/lib/skill-evolution/versioning.js index 6aa7a932d..349b49b1b 100644 --- a/scripts/lib/skill-evolution/versioning.js +++ b/scripts/lib/skill-evolution/versioning.js @@ -83,7 +83,8 @@ function parseVersionNumber(fileName) { return null; } - return Number(match[1]); + const version = Number(match[1]); + return Number.isSafeInteger(version) && version >= 1 ? version : null; } function listVersions(skillPath) { @@ -100,7 +101,17 @@ function listVersions(skillPath) { } const filePath = path.join(versionsDir, fileName); - const stats = fs.statSync(filePath); + let stats; + try { + stats = fs.statSync(filePath); + } catch (error) { + // A dangling link still occupies a path, but is not a readable snapshot. + if (error.code === 'ENOENT') return null; + throw error; + } + if (!stats.isFile()) { + return null; + } return { version, @@ -143,7 +154,10 @@ function readJsonl(filePath) { .filter(Boolean) .reduce((rows, line) => { try { - rows.push(JSON.parse(line)); + const record = JSON.parse(line); + if (record && typeof record === 'object' && !Array.isArray(record)) { + rows.push(record); + } } catch { // Ignore malformed rows so the log remains append-only and resilient. } @@ -155,56 +169,222 @@ function getEvolutionLog(skillPath, logType) { return readJsonl(getEvolutionLogPath(skillPath, logType)); } -function createVersion(skillPath, options = {}) { - const skillFilePath = ensureSkillExists(skillPath); - ensureSkillVersioning(skillPath); - +function allocateSnapshotVersion(skillPath) { const versions = listVersions(skillPath); - const nextVersion = versions.length === 0 ? 1 : versions[versions.length - 1].version + 1; - const snapshotPath = path.join(getVersionsDir(skillPath), `v${nextVersion}.md`); - const skillContent = fs.readFileSync(skillFilePath, 'utf8'); - const createdAt = options.timestamp || new Date().toISOString(); + const versionsDir = getVersionsDir(skillPath); + const occupiedPaths = new Set(fs.existsSync(versionsDir) ? fs.readdirSync(versionsDir) : []); + let nextVersion = versions.length === 0 ? 1 : versions[versions.length - 1].version + 1; + // Listing excludes non-files, but their paths remain user-owned and occupied. + while (Number.isSafeInteger(nextVersion) && occupiedPaths.has(`v${nextVersion}.md`)) { + nextVersion += 1; + } + if (!Number.isSafeInteger(nextVersion)) { + throw new Error('Skill snapshot version range is exhausted; safe integer allocation is unavailable; existing snapshots were preserved'); + } + return nextVersion; +} - fs.writeFileSync(snapshotPath, skillContent, 'utf8'); +function removeOwnedSnapshot(snapshot) { + let current; + try { + current = fs.lstatSync(snapshot.path); + } catch (error) { + if (error.code === 'ENOENT') return; + throw error; + } + if (!current.isFile() || current.dev !== snapshot.identity.dev || current.ino !== snapshot.identity.ino) { + throw new Error('Snapshot path changed ownership; replacement was preserved'); + } + fs.unlinkSync(snapshot.path); +} + +function failSnapshotAttempt(snapshot, primaryError) { + try { + removeOwnedSnapshot(snapshot); + } catch (recoveryError) { + const error = new Error(`${primaryError.message}; snapshot cleanup failed: ${recoveryError.message}; recovery is pending`, { cause: primaryError }); + error.primaryError = primaryError; + error.recoveryError = recoveryError; + throw error; + } + throw primaryError; +} + +function removeOwnedStaging(staging, contentIdentity) { + const directory = fs.lstatSync(staging.path); + if (!directory.isDirectory() || directory.dev !== staging.identity.dev || directory.ino !== staging.identity.ino) { + throw new Error('Snapshot staging directory changed ownership; replacement was preserved'); + } + let content; + try { + content = fs.lstatSync(staging.contentPath); + } catch (error) { + if (error.code !== 'ENOENT') throw error; + } + if (content) { + if (!contentIdentity || !content.isFile() || content.dev !== contentIdentity.dev || content.ino !== contentIdentity.ino) { + throw new Error('Snapshot staging content ownership could not be verified; content was preserved'); + } + fs.unlinkSync(staging.contentPath); + } + // Unexpected entries remain owned by their writers. Empty-directory removal is safe. + fs.rmdirSync(staging.path); +} + +function prepareStaging(versionsDir, prefix = '.snapshot-') { + const stagingDir = fs.mkdtempSync(path.join(versionsDir, prefix)); + try { + return { path: stagingDir, contentPath: path.join(stagingDir, 'content.md'), identity: fs.lstatSync(stagingDir) }; + } catch (primaryError) { + const recoveryError = new Error(`Staging directory identity could not be verified; preserved ${stagingDir}`); + const error = new Error(`${primaryError.message}; ${recoveryError.message}; recovery is pending`, { cause: primaryError }); + error.primaryError = primaryError; + error.recoveryError = recoveryError; + throw error; + } +} + +function verifySnapshotStorage(skillPath) { + const versionsDir = getVersionsDir(skillPath); + const base = fs.existsSync(versionsDir) ? versionsDir : normalizeSkillDir(skillPath); + const staging = prepareStaging(base, '.snapshot-storage-'); + const linkPath = path.join(staging.path, 'hardlink-check.md'); + let identity; + let linked = false; + let linking = false; + try { + const descriptor = fs.openSync(staging.contentPath, 'wx'); + try { + identity = fs.fstatSync(descriptor); + fs.writeFileSync(descriptor, 'ECC snapshot storage check\n', 'utf8'); + } finally { + fs.closeSync(descriptor); + } + linking = true; + fs.linkSync(staging.contentPath, linkPath); + linked = true; + linking = false; + removeOwnedSnapshot({ path: linkPath, identity }); + linked = false; + removeOwnedStaging(staging, identity); + } catch (primaryError) { + try { + if (linked) removeOwnedSnapshot({ path: linkPath, identity }); + removeOwnedStaging(staging, identity); + } catch (recoveryError) { + const error = new Error(`${primaryError.message}; storage-check cleanup failed: ${recoveryError.message}; recovery is pending`, { cause: primaryError }); + error.primaryError = primaryError; + error.recoveryError = recoveryError; + throw error; + } + if (linking && ['ENOTSUP', 'EOPNOTSUPP', 'ENOSYS', 'EPERM', 'EXDEV', 'EINVAL'].includes(primaryError.code)) { + const error = new Error(`Skill versioning requires hardlink-capable storage for snapshot creation and rollback; capability check failed before history initialization (${primaryError.code})`, { cause: primaryError }); + error.code = primaryError.code; + error.primaryError = primaryError; + throw error; + } + throw primaryError; + } +} + +function publishVersion(skillPath, skillContent, options) { + ensureSkillExists(skillPath); + const nextVersion = allocateSnapshotVersion(skillPath); + const versionsDir = getVersionsDir(skillPath); + verifySnapshotStorage(skillPath); + ensureSkillVersioning(skillPath); + const staging = prepareStaging(versionsDir); + const stagedPath = staging.contentPath; + const snapshotPath = path.join(versionsDir, `v${nextVersion}.md`); + const createdAt = options.timestamp || new Date().toISOString(); + let snapshot; + let published = false; + try { + const descriptor = fs.openSync(stagedPath, 'wx'); + try { + snapshot = { version: nextVersion, path: snapshotPath, created_at: createdAt, identity: fs.fstatSync(descriptor) }; + fs.writeFileSync(descriptor, skillContent, 'utf8'); + } finally { + fs.closeSync(descriptor); + } + // Exclusive linking publishes fully written bytes without replacing occupied paths. + fs.linkSync(stagedPath, snapshotPath); + published = true; + removeOwnedStaging(staging, snapshot.identity); + return snapshot; + } catch (primaryError) { + try { + if (published) removeOwnedSnapshot(snapshot); + removeOwnedStaging(staging, snapshot?.identity); + } catch (recoveryError) { + const error = new Error(`${primaryError.message}; publication cleanup failed: ${recoveryError.message}; recovery is pending`, { cause: primaryError }); + error.primaryError = primaryError; + error.recoveryError = recoveryError; + throw error; + } + throw primaryError; + } +} + +function recordSnapshot(skillPath, snapshot, options) { appendEvolutionRecord(skillPath, 'amendments', { event: 'snapshot', - version: nextVersion, + version: snapshot.version, reason: options.reason || null, author: options.author || null, status: 'applied', - created_at: createdAt, + created_at: snapshot.created_at, }); + return { version: snapshot.version, path: snapshot.path, created_at: snapshot.created_at }; +} - return { - version: nextVersion, - path: snapshotPath, - created_at: createdAt, - }; +/** Snapshot creation requires hardlink-capable storage, checked before history initialization. */ +function createVersion(skillPath, options = {}) { + const skillFilePath = ensureSkillExists(skillPath); + const skillContent = fs.readFileSync(skillFilePath, 'utf8'); + return recordSnapshot(skillPath, publishVersion(skillPath, skillContent, options), options); } function rollbackTo(skillPath, targetVersion, options = {}) { const normalizedTargetVersion = Number(targetVersion); - if (!Number.isInteger(normalizedTargetVersion) || normalizedTargetVersion <= 0) { + if (!Number.isSafeInteger(normalizedTargetVersion) || normalizedTargetVersion <= 0) { throw new Error(`Invalid target version: ${targetVersion}`); } ensureSkillExists(skillPath); - ensureSkillVersioning(skillPath); const targetPath = path.join(getVersionsDir(skillPath), `v${normalizedTargetVersion}.md`); if (!fs.existsSync(targetPath)) { throw new Error(`Version not found: v${normalizedTargetVersion}`); } + const priorContent = fs.readFileSync(getSkillFilePath(skillPath)); const currentVersion = getCurrentVersion(skillPath); const targetContent = fs.readFileSync(targetPath, 'utf8'); - fs.writeFileSync(getSkillFilePath(skillPath), targetContent, 'utf8'); - - const createdVersion = createVersion(skillPath, { + // Publish the restored-content snapshot before replacing unsnapshotted live work. + // Initialization and exclusive publication failures therefore leave SKILL.md intact. + const snapshotOptions = { timestamp: options.timestamp, reason: options.reason || `rollback to v${normalizedTargetVersion}`, author: options.author || null, - }); + }; + const snapshot = publishVersion(skillPath, targetContent, snapshotOptions); + try { + fs.writeFileSync(getSkillFilePath(skillPath), targetContent, 'utf8'); + } catch (primaryError) { + try { + if (!fs.readFileSync(getSkillFilePath(skillPath)).equals(priorContent)) { + throw new Error('Live skill changed during the failed write; target snapshot retained'); + } + } catch (recoveryError) { + const error = new Error(`${primaryError.message}; ${recoveryError.message}; recovery is pending`, { cause: primaryError }); + error.primaryError = primaryError; + error.recoveryError = recoveryError; + throw error; + } + failSnapshotAttempt(snapshot, primaryError); + } + const createdVersion = recordSnapshot(skillPath, snapshot, snapshotOptions); appendEvolutionRecord(skillPath, 'amendments', { event: 'rollback', diff --git a/scripts/lib/statusline-render.js b/scripts/lib/statusline-render.js index 74cdd11b8..6d145859d 100644 --- a/scripts/lib/statusline-render.js +++ b/scripts/lib/statusline-render.js @@ -217,30 +217,55 @@ function buildEccLine(info) { return parts.join(SEP); } +function pluginProjectRoot(workspace) { + const cwd = path.resolve(workspace || process.cwd()); + for (let candidate = cwd; ; candidate = path.dirname(candidate)) { + if (fs.existsSync(path.join(candidate, '.git'))) return candidate; + if (candidate === path.dirname(candidate)) return cwd; + } +} + +function pluginEnablement(files) { + return files.reduce((enabled, file) => { + try { + const value = JSON.parse(fs.readFileSync(file, 'utf8')).enabledPlugins; + return value && typeof value === 'object' && !Array.isArray(value) ? { ...enabled, ...value } : enabled; + } catch { return enabled; /* Missing or malformed optional display settings. */ } + }, {}); +} + /** - * Enabled plugins with versions, ecc first. - * Reads installed_plugins.json (v2) and settings.json enabledPlugins. - * @param {string} [claudeDir] - defaults to CLAUDE_CONFIG_DIR or ~/.claude + * User and applicable project/local plugin metadata for the current Git root. + * Project-local enablement overrides shared-project and selected user settings. + * This display helper does not reproduce managed or per-session host policy. + * @param {string} [claudeDir] selected profile root + * @param {string} [workspace] current working directory * @returns {Array<{name: string, version: string}>} */ -function readInstalledPlugins(claudeDir) { +function readInstalledPlugins(claudeDir, workspace) { try { const dir = claudeDir || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'); const installed = JSON.parse( fs.readFileSync(path.join(dir, 'plugins', 'installed_plugins.json'), 'utf8') ); - let enabled = null; - try { - const settings = JSON.parse(fs.readFileSync(path.join(dir, 'settings.json'), 'utf8')); - if (settings.enabledPlugins && typeof settings.enabledPlugins === 'object') { - enabled = settings.enabledPlugins; - } - } catch { /* no settings \u2014 show all installed */ } + const project = pluginProjectRoot(workspace); + const normalized = value => process.platform === 'win32' ? path.resolve(value).toLowerCase() : path.resolve(value); + const enabled = pluginEnablement([path.join(dir, 'settings.json'), + path.join(project, '.claude', 'settings.json'), path.join(project, '.claude', 'settings.local.json')]); + const ranks = { user: 0, project: 1, local: 2 }; + const applicable = entry => entry && typeof entry === 'object' && + ((!entry.scope || entry.scope === 'user') || + (['project', 'local'].includes(entry.scope) && typeof entry.projectPath === 'string' && + normalized(entry.projectPath) === normalized(project))); const plugins = []; for (const [id, entries] of Object.entries(installed?.plugins || {})) { - if (enabled && enabled[id] === false) continue; - const entry = Array.isArray(entries) ? entries[0] : entries; + if (enabled[id] === false) continue; + const entry = (Array.isArray(entries) ? entries : [entries]).filter(applicable).sort((a, b) => + (ranks[b.scope || 'user'] - ranks[a.scope || 'user']) || + String(b.lastUpdated || b.installedAt || '').localeCompare(String(a.lastUpdated || a.installedAt || '')) || + String(b.version || '').localeCompare(String(a.version || '')))[0]; + if (!entry) continue; plugins.push({ name: id.split('@')[0], version: entry?.version || '' }); } plugins.sort((a, b) => (a.name === 'ecc' ? -1 : b.name === 'ecc' ? 1 : a.name.localeCompare(b.name))); diff --git a/skills/continuous-learning-v2/scripts/instinct-cli.py b/skills/continuous-learning-v2/scripts/instinct-cli.py index f7f35abbb..d6b0820cd 100755 --- a/skills/continuous-learning-v2/scripts/instinct-cli.py +++ b/skills/continuous-learning-v2/scripts/instinct-cli.py @@ -525,7 +525,7 @@ def parse_instinct_file(content: str) -> list[dict]: in_frontmatter = False content_lines = [] - for line in content.split('\n'): + for line in content.removeprefix('\ufeff').split('\n'): if line.strip() == '---': if in_frontmatter: # End of frontmatter - content comes next @@ -551,7 +551,8 @@ def parse_instinct_file(content: str) -> list[dict]: value = value[1:-1].replace("''", "'") if key == 'confidence': try: - current[key] = float(value) + confidence = float(value) + current[key] = confidence if 0.0 <= confidence <= 1.0 else 0.5 except ValueError: current[key] = 0.5 # default on malformed confidence else: diff --git a/skills/continuous-learning-v2/scripts/test_parse_instinct.py b/skills/continuous-learning-v2/scripts/test_parse_instinct.py index f58c58853..f1c65f0c6 100644 --- a/skills/continuous-learning-v2/scripts/test_parse_instinct.py +++ b/skills/continuous-learning-v2/scripts/test_parse_instinct.py @@ -208,6 +208,23 @@ Prevents vulnerabilities. assert "Prevents vulnerabilities." in result[0]["content"] +@pytest.mark.parametrize("newline", ["\n", "\r\n"]) +def test_parse_initial_utf8_bom(newline): + content = SAMPLE_INSTINCT_YAML.replace("\n", newline) + assert parse_instinct_file("\ufeff" + content) == parse_instinct_file(content) + + +def test_parse_preserves_bom_inside_content(): + content = SAMPLE_INSTINCT_YAML.replace("Always write", "Always \ufeffwrite") + assert "Always \ufeffwrite" in parse_instinct_file(content)[0]["content"] + + +def test_load_instinct_file_with_utf8_bom(tmp_path): + (tmp_path / "bom.yaml").write_text(SAMPLE_INSTINCT_YAML, encoding="utf-8-sig") + instincts = _load_instincts_from_dir(tmp_path, "personal", "project") + assert [instinct["id"] for instinct in instincts] == ["test-instinct"] + + def test_empty_content_no_error(): content = """\ --- @@ -252,6 +269,18 @@ Body. assert result[0]["confidence"] == pytest.approx(0.42) +@pytest.mark.parametrize("confidence", ["nan", "inf", "-inf", "1e309", "-0.1", "1.1", "invalid"]) +def test_parse_invalid_confidence_uses_default(confidence): + content = SAMPLE_INSTINCT_YAML.replace("confidence: 0.8", f"confidence: {confidence}") + assert parse_instinct_file(content)[0]["confidence"] == 0.5 + + +@pytest.mark.parametrize("confidence", [0.0, 0.42, 1.0]) +def test_parse_confidence_preserves_valid_range(confidence): + content = SAMPLE_INSTINCT_YAML.replace("confidence: 0.8", f"confidence: {confidence}") + assert parse_instinct_file(content)[0]["confidence"] == confidence + + def test_parse_trigger_strips_quotes(): content = """\ --- @@ -671,6 +700,17 @@ def test_cmd_status_with_instincts(patch_globals, monkeypatch, capsys): assert "GLOBAL" in out +@pytest.mark.parametrize("confidence", ["inf", "-inf", "nan"]) +def test_cmd_status_handles_nonfinite_confidence(patch_globals, monkeypatch, capsys, confidence): + project = _make_project(patch_globals) + monkeypatch.setattr(_mod, "detect_project", lambda: project) + content = SAMPLE_INSTINCT_YAML.replace("confidence: 0.8", f"confidence: {confidence}") + (project["instincts_personal"] / "nonfinite.yaml").write_text(content, encoding="utf-8") + + assert cmd_status(SimpleNamespace()) == 0 + assert "50%" in capsys.readouterr().out + + def test_confidence_bar_uses_unicode_when_supported(): """Confidence bars should retain block glyphs on UTF-8 streams.""" stream = SimpleNamespace(encoding="utf-8") diff --git a/skills/delivery-gate/SKILL.md b/skills/delivery-gate/SKILL.md index 0a98d2636..940e26160 100644 --- a/skills/delivery-gate/SKILL.md +++ b/skills/delivery-gate/SKILL.md @@ -35,8 +35,11 @@ Over many sessions of "ship and forget," the human hasn't grown. This hook enfor ## Install +From the ECC repository root: + ```bash -cp quality-gate.py ~/.claude/scripts/ +mkdir -p ~/.claude/scripts +cp skills/delivery-gate/hooks/quality-gate.py ~/.claude/scripts/ ``` Add to `~/.claude/settings.json`: diff --git a/skills/docker-patterns/SKILL.md b/skills/docker-patterns/SKILL.md index 5f096dbe3..36e792966 100644 --- a/skills/docker-patterns/SKILL.md +++ b/skills/docker-patterns/SKILL.md @@ -428,11 +428,14 @@ without a bridge. The `real-cli-networked` service publishes host logging in: ```bash -npm install --global @openai/codex@0.162.0 # the harness image does not ship codex -node /ecc/docker/plugin-setup/codex-auth-relay.js & -relay_pid=$! -codex login -kill "$relay_pid" +( + set -e + npm install --global @openai/codex@0.162.0 # the harness image does not ship codex + node /ecc/docker/plugin-setup/codex-auth-relay.js & + relay_pid=$! + trap 'kill "$relay_pid" 2>/dev/null || true; wait "$relay_pid" 2>/dev/null || true' EXIT + codex login +) ``` The networked service sets `NPM_CONFIG_PREFIX=/tmp/ecc-npm` and adds its `bin` @@ -442,7 +445,8 @@ on the executable `/tmp` mount while the root filesystem remains read-only. Complete the sign-in in the host browser. Each attempt mints a fresh `state`/`code`, so always follow the newest printed link. The token stays in the disposable container's `~/.codex/auth.json`; removing the named container -deletes that credential copy. Stop the relay after the login attempt. Only one container can hold host port 1455 at a time +deletes that credential copy. The login block stops the relay on success or failure. +Only one container can hold host port 1455 at a time because the OAuth redirect targets a fixed port. The host publish is restricted to loopback. Inside the container, the relay diff --git a/skills/gateguard/SKILL.md b/skills/gateguard/SKILL.md index 5db374d63..208174601 100644 --- a/skills/gateguard/SKILL.md +++ b/skills/gateguard/SKILL.md @@ -400,8 +400,8 @@ An Edit, Write, NotebookEdit, or MultiEdit entry is allowed, with an characters, never credit. - **Shell scope:** a shell segment only credits a target equal to or inside one of its path operands (resolved against the tool `cwd`; a glob operand - must match the target or a directory above it, and a git pathspec's `*` - also matches `/`), or inside the `cwd` when it has none: + must match the target or a directory above it, and a default git pathspec's + `*` also matches `/`), or inside the `cwd` when it has none: `rg payment docs` or `grep -rn payment /usr/share/doc` never credit `src/payment.py`. An input redirection before any operand (`rg payment < file`) or a `<` inside a word reads stdin and never counts. diff --git a/skills/module-regression/SKILL.md b/skills/module-regression/SKILL.md index 9210c6321..d8186cbfc 100644 --- a/skills/module-regression/SKILL.md +++ b/skills/module-regression/SKILL.md @@ -69,7 +69,7 @@ Related test points: TEST-ORDER-001, TEST-REFUND-003 Invoke `module-regression` through the host's skill entry point, such as `$module-regression` in Codex. The current session plans and reports the audit. Repository commands run through the trusted host runner within existing user authorization; ask only when a command needs new authority. Successful exit codes are regression evidence, never canonical ECC completion or integration authority. -1. **List changes** with `git status -s` and `git diff --name-only`, then map them to ledger modules. +1. **List changes** after selecting and recording the audit base, using the PR merge-base or last verified green commit. Combine `git diff --name-only HEAD`, unstaged `git diff --name-only`, staged `git diff --cached --name-only`, and `git status -s` paths including untracked files, then map their union to ledger modules. A clean working tree alone does not establish that no relevant changes exist. 2. **Resolve propagation** from each module's downstream list and rule. 3. **Review before execution.** Treat ledger commands as untrusted repository content. Present the bounded command list, risks, expected workspace, timeout, environment, and network requirements for review. Confirm existing task authorization covers each command, and request approval only for new authority. Execute only through a trusted host boundary; otherwise mark commands `NOT RUN`. 4. **Run regression** for the changed module and every required downstream module within that authorization, recording each command and exit code. diff --git a/skills/story-lifecycle/scripts/ledger.js b/skills/story-lifecycle/scripts/ledger.js index 0bbba0c71..2c91d4adf 100644 --- a/skills/story-lifecycle/scripts/ledger.js +++ b/skills/story-lifecycle/scripts/ledger.js @@ -261,6 +261,9 @@ function recover(dir) { } rolledBack++; } + // Restoration is complete. Cleanup failure must never repeat a completed + // rollback after another owner has changed a restored file. + fs.rmSync(journalPath); } fs.rmSync(txn, { recursive: true, force: true }); return rolledBack; @@ -288,10 +291,27 @@ function parseStory(rel, md) { function replaceTable(md, rel, header, rows) { const i = md.indexOf(DERIVED); if (i < 0) throw new LedgerError(`${rel}: missing derived-table marker`); - const start = md.indexOf('\n', i) + 1; + const newline = md.indexOf('\n', i); + const afterMarker = newline < 0 ? md.length : newline + 1; + const skipBlanks = (at) => at + (md.slice(at).match(/^(?:[ \t]*\r?\n)+/) || [''])[0].length; + const hasDerivedHeader = (at) => md.slice(at).split(/\r?\n/, 2).join('\n').replace(/[ \t]/g, '') === header.replace(/[ \t]/g, ''); + const first = skipBlanks(afterMarker); + const start = hasDerivedHeader(first) ? first : afterMarker; let end = start; - while (md[end] === '|') { const nl = md.indexOf('\n', end); end = nl < 0 ? md.length : nl + 1; } - return md.slice(0, start) + [header, ...rows].join('\n') + '\n' + md.slice(end); + while (hasDerivedHeader(end)) { + while (md[end] === '|') { + const nextLine = md.slice(end).split(/\r?\n/, 2)[1] || ''; + if (end !== start && /^\|(?:\s*:?-{3,}:?\s*\|)+\s*$/.test(nextLine) && !hasDerivedHeader(end)) break; + const nl = md.indexOf('\n', end); end = nl < 0 ? md.length : nl + 1; + } + // Older projections could insert a second table before a blank-separated + // original. Only adjacent copies of this derived header belong to us. + const next = skipBlanks(end); + if (!hasDerivedHeader(next)) break; + end = next; + } + const separator = start === end && md[start] === '|' ? '\n' : ''; + return md.slice(0, start) + (newline < 0 ? '\n' : '') + [header, ...rows].join('\n') + '\n' + separator + md.slice(end); } // Read the ledger with pending changes overlaid; return regenerated epic/sprint files that differ. @@ -311,15 +331,16 @@ function project(dir, pending = {}) { } } const derived = {}; + const cell = (title) => title.replace(/\\/g, '\\\\').replace(/\|/g, '\\|'); for (const rel of list('epics', EPIC_FILE)) { const slug = rel.match(EPIC_FILE)[1]; - const rows = stories.filter((s) => s.epic === slug).map((s) => `| ${s.id} | ${s.title} | ${s.status} |`); + const rows = stories.filter((s) => s.epic === slug).map((s) => `| ${s.id} | ${cell(s.title)} | ${s.status} |`); const next = replaceTable(read(rel), rel, '| ID | Title | Status |\n| --- | --- | --- |', rows); if (next !== read(rel)) derived[rel] = next; } for (const rel of sprints) { const inSprint = stories.filter((s) => s.sprint === rel.match(SPRINT_FILE)[1]); - const rows = inSprint.map((s) => `| ${s.id} | ${s.title} | ${s.points} | ${s.status} |`); + const rows = inSprint.map((s) => `| ${s.id} | ${cell(s.title)} | ${s.points} | ${s.status} |`); const total = inSprint.reduce((sum, s) => sum + Number(s.points), 0); const next = replaceTable(read(rel), rel, '| ID | Title | Points | Status |\n| --- | --- | --- | --- |', rows) .replace(/^## Total Points:.*$/m, `## Total Points: ${total}`); @@ -365,38 +386,7 @@ function allocate(root, dir, epic, count) { return { ids }; } -// changes: { create: { rel: content }, update: { rel: content } } -function apply(root, dir, changes) { - const keys = new Set(); - const normalize = (obj = {}) => Object.fromEntries(Object.entries(obj).map(([rel, content]) => { - const key = rel.replace(/\\/g, '/'); - if (keys.has(key)) throw new LedgerError(`duplicate path in batch: ${key}`); - keys.add(key); - return [key, content]; - })); - const create = normalize(changes.create); - const update = normalize(changes.update); - const reg = registryDir(root, dir); - for (const rel of Object.keys(create)) { - if (fs.existsSync(resolveLedgerPath(dir, rel))) throw new LedgerError(`refusing to overwrite existing ${rel}`, 4); - const m = rel.match(STORY_FILE); - if (m && !fs.existsSync(path.join(reg, `${m[1]}-${m[2]}`))) throw new LedgerError(`${rel}: story ID was not allocated`); - if (m && parseStory(rel, create[rel]).status !== 'todo') throw new LedgerError(`${rel}: new stories start as todo`); - } - for (const rel of Object.keys(update)) { - const abs = resolveLedgerPath(dir, rel); - if (!fs.existsSync(abs)) throw new LedgerError(`cannot update missing ${rel}`); - if (!STORY_FILE.test(rel)) continue; - const from = parseStory(rel, readRegular(abs, 'utf8')).status; - const to = parseStory(rel, update[rel]).status; - if (to !== from && STATUSES.indexOf(to) !== STATUSES.indexOf(from) + 1) { - throw new LedgerError(`${rel}: status ${from} -> ${to} is not allowed; status moves forward one step at a time`); - } - } - const pending = { ...create, ...update }; - const all = { ...pending, ...project(dir, pending).derived }; - const txn = path.join(dir, '.txn'); - fs.mkdirSync(txn, { mode: 0o700 }); +function publishTransaction(dir, txn, all, create) { const entries = Object.keys(all).map((rel, i) => { const existed = fs.existsSync(resolveLedgerPath(dir, rel)); if (rel in create && existed) throw new LedgerError(`refusing to overwrite existing ${rel}`, 4); @@ -428,6 +418,70 @@ function apply(root, dir, changes) { return { ok: true, written: entries.map((e) => e.path) }; } +// changes: { create: { rel: content }, update: { rel: content } } +function apply(root, dir, changes) { + const keys = new Set(); + const normalize = (obj = {}) => Object.fromEntries(Object.entries(obj).map(([rel, content]) => { + const key = rel.replace(/\\/g, '/'); + if (keys.has(key)) throw new LedgerError(`duplicate path in batch: ${key}`); + keys.add(key); + return [key, content]; + })); + const create = normalize(changes.create); + const update = normalize(changes.update); + const reg = registryDir(root, dir); + for (const rel of Object.keys(create)) { + if (fs.existsSync(resolveLedgerPath(dir, rel))) throw new LedgerError(`refusing to overwrite existing ${rel}`, 4); + const m = rel.match(STORY_FILE); + if (m && !fs.existsSync(path.join(reg, `${m[1]}-${m[2]}`))) throw new LedgerError(`${rel}: story ID was not allocated`); + if (m && parseStory(rel, create[rel]).status !== 'todo') throw new LedgerError(`${rel}: new stories start as todo`); + } + for (const rel of Object.keys(update)) { + const abs = resolveLedgerPath(dir, rel); + if (!fs.existsSync(abs)) throw new LedgerError(`cannot update missing ${rel}`); + if (!STORY_FILE.test(rel)) continue; + const from = parseStory(rel, readRegular(abs, 'utf8')).status; + const to = parseStory(rel, update[rel]).status; + if (to !== from && STATUSES.indexOf(to) !== STATUSES.indexOf(from) + 1) { + throw new LedgerError(`${rel}: status ${from} -> ${to} is not allowed; status moves forward one step at a time`); + } + } + const pending = { ...create, ...update }; + const all = { ...pending, ...project(dir, pending).derived }; + return withTransaction(dir, txn => publishTransaction(dir, txn, all, create)); +} + +function describeError(error) { return `${error.code ? `${error.code}: ` : ''}${error.message}`; } + +function withOwnerLock(dir, waitMs, operation) { + const release = acquireLock(dir, waitMs); + let result, primaryError; + try { result = operation(); } catch (error) { primaryError = error; } + try { release(); } catch (releaseError) { + if (!primaryError) throw releaseError; + throw new LedgerError(`${describeError(primaryError)}; lock release failed: ${describeError(releaseError)}`, primaryError.exitCode || 1); + } + if (primaryError) throw primaryError; + return result; +} + +function withTransaction(dir, operation) { + const txn = path.join(dir, '.txn'); + fs.mkdirSync(txn, { mode: 0o700 }); + try { + return operation(txn); + } catch (error) { + // Caller retains the live owner lock throughout restoration. A removed + // journal marks a committed batch, so recover then only cleans debris. + try { recover(dir); } catch (recoveryError) { + const state = fs.existsSync(path.join(dir, '.txn', 'journal.json')) ? 'recovery pending' : 'transaction cleanup pending'; + throw new LedgerError(`${describeError(error)}; ${state}: ${describeError(recoveryError)}; ` + + 'resolve the cause, then run recover to retry without overwriting foreign-owned files.', error.exitCode || 1); + } + throw error; + } +} + function main() { const opts = parseArgs(process.argv.slice(2)); const cmd = opts._[0]; @@ -450,17 +504,14 @@ function main() { throw new LedgerError('--wait-ms must be an integer in 0..60000'); } requireHardlinks(dir); - const release = acquireLock(dir, waitMs); - try { + return withOwnerLock(dir, waitMs, () => { const rolledBack = recover(dir); if (cmd === 'recover') return { ok: true, rolledBack }; if (cmd === 'allocate') return allocate(root, dir, opts.epic, Number(opts.count || 1)); if (cmd === 'reconcile') return apply(root, dir, {}); if (cmd === 'apply') return apply(root, dir, JSON.parse(fs.readFileSync(opts.input, 'utf8'))); throw new LedgerError(`unknown command: ${cmd}`); - } finally { - release(); - } + }); } if (require.main === module) { diff --git a/src/llm/providers/resolver.py b/src/llm/providers/resolver.py index d4754a288..248e8bf92 100644 --- a/src/llm/providers/resolver.py +++ b/src/llm/providers/resolver.py @@ -69,10 +69,10 @@ def _resolve_provider_config( return _strip_env_value(env_provider).lower(), None saved_config = _read_saved_llm_config() - saved_provider = saved_config.get("LLM_PROVIDER", "claude").lower() + saved_provider = saved_config.get("LLM_PROVIDER", "").lower() # A saved model belongs to its saved provider, never to an override. - saved_model = saved_config.get("LLM_MODEL") if saved_config.get("LLM_PROVIDER") else None - return saved_provider, saved_model + saved_model = saved_config.get("LLM_MODEL") if saved_provider else None + return saved_provider or "claude", saved_model def _resolve_default_model( diff --git a/tests/docker/codex-auth-relay.test.js b/tests/docker/codex-auth-relay.test.js index 2ddc85c87..5a70b291f 100644 --- a/tests/docker/codex-auth-relay.test.js +++ b/tests/docker/codex-auth-relay.test.js @@ -70,3 +70,21 @@ for (const port of ['1455', '24567']) { assert.equal(child.stdout, ''); }); } + +test('occupied listener reports a bounded relay diagnostic without a startup banner', { timeout: 5000 }, async t => { + const occupied = net.createServer(); + occupied.listen(0, '0.0.0.0'); + await once(occupied, 'listening'); + t.after(() => new Promise(resolve => occupied.close(resolve))); + const port = occupied.address().port; + const child = spawn(process.execPath, [script], { env: { ...process.env, + ECC_RELAY_LISTEN: String(port), ECC_RELAY_TARGET: String(port === 1455 ? 1456 : 1455) } }); + let stderr = '';let stdout = ''; + child.stderr.on('data', chunk => { stderr += chunk; }); + child.stdout.on('data', chunk => { stdout += chunk; }); + const [code] = await once(child, 'close'); + assert.equal(code, 1); + assert.match(stderr, /^codex-auth-relay: .*EADDRINUSE/m); + assert.doesNotMatch(stderr, /Unhandled 'error' event/); + assert.equal(stdout, ''); +}); diff --git a/tests/docs/story-lifecycle-errors.test.js b/tests/docs/story-lifecycle-errors.test.js new file mode 100644 index 000000000..e1dc7e508 --- /dev/null +++ b/tests/docs/story-lifecycle-errors.test.js @@ -0,0 +1,115 @@ +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const { execFileSync, spawnSync } = require('node:child_process'); +const LEDGER = path.join(__dirname, '../../skills/story-lifecycle/scripts/ledger.js'); +const temps = new Set(); +const marker = ''; +const epic = `# Epic: Auth\n\n${marker}\n| ID | Title | Status |\n| --- | --- | --- |\n`; +const story = (id, status = 'todo') => `# Story: ${id}\n\n**ID:** ${id}\n**Epic:** auth\n**Sprint:** unassigned\n**Status:** ${status}\n**Points:** 3\n`; +function run(root, args, preload) { + return spawnSync(process.execPath, [...(preload ? ['-r', preload] : []), LEDGER, ...args, '--root', root], + { encoding: 'utf8', timeout: 15000 }); +} +function ok(result) { assert.equal(result.status, 0, result.stderr); return JSON.parse(result.stdout); } +function input(root, changes) { const file = path.join(root, 'input.json'); fs.writeFileSync(file, JSON.stringify(changes)); return file; } +function snapshot(dir) { + return Object.fromEntries(fs.readdirSync(dir, { withFileTypes: true }) + .sort((left, right) => left.name.localeCompare(right.name)).map(entry => { + const file = path.join(dir, entry.name); + if (entry.isDirectory()) return [entry.name, snapshot(file)]; + const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW); + try { + assert.ok(fs.fstatSync(fd).isFile(), 'snapshot requires a regular file'); + return [entry.name, fs.readFileSync(fd, 'base64')]; + } finally { fs.closeSync(fd); } + })); +} +function fixture(update = false) { + const root = fs.mkdtempSync(path.join(os.tmpdir(), 'story-ordinary-error-'));temps.add(root); + execFileSync('git', ['init', '-q', root]);ok(run(root, ['init'])); + fs.writeFileSync(path.join(root, '.stories/epics/auth.md'), epic); + const ids = ok(run(root, ['allocate', '--epic', 'auth', '--count', '2'])).ids; + if (update) ok(run(root, ['apply', '--input', input(root, { create: Object.fromEntries(ids.map(id => [`${id}.md`, story(id)])) })])); + const before = snapshot(path.join(root, '.stories')); + const changes = { [update ? 'update' : 'create']: Object.fromEntries(ids.map(id => [`${id}.md`, story(id, update ? 'in-progress' : 'todo')])) }; + return { root, ids, before, registryBefore: snapshot(path.join(root, '.git/story-lifecycle')), file: input(root, changes) }; +} +function fault(root, { recoveryFailure = false, cleanupFailure = false, journalRemovalFailure = false, releaseFailure = false } = {}) { + const file = path.join(root, 'bounded-fault.cjs'); + fs.writeFileSync(file, `const fs=require('node:fs');const path=require('node:path'); +const dir=${JSON.stringify(path.join(root, '.stories'))};const trace=${JSON.stringify(path.join(root, 'trace.json'))}; +const state={published:0,recoveryLocks:[]};const save=()=>fs.writeFileSync(trace,JSON.stringify(state)); +const failure=(text,code)=>Object.assign(new Error(text),{code}); +for(const method of ['linkSync','renameSync']){const original=fs[method];fs[method]=function(source,target,...args){ + const publication=path.dirname(target)===dir && /^auth-[12]\\.md$/.test(path.basename(target)) && /^new-\\d+$/.test(path.basename(source)); + if(publication && state.published===1 && ${!cleanupFailure}){state.primary=true;state.firstBytes=fs.readFileSync(path.join(dir,'auth-1.md')).toString('base64');state.lock=JSON.parse(fs.readFileSync(path.join(dir,'.lock'),'utf8'));save();throw failure('PRIMARY ordinary second publication','EIO');} + if(path.basename(source).startsWith('backup-')){const holder=JSON.parse(fs.readFileSync(path.join(dir,'.lock'),'utf8'));state.recoveryLocks.push(holder.pid===process.pid);save(); + if(${recoveryFailure} && path.basename(target)==='restore.tmp' && path.basename(source)==='backup-1')throw failure('RECOVERY backup restore refused','EACCES');} + const result=original.call(fs,source,target,...args);if(publication){state.published++;save();}return result; +};} +${journalRemovalFailure ? "const rmJournal=fs.rmSync;fs.rmSync=function(target,...args){if(target===path.join(dir,'.txn','journal.json') && state.primary && state.recoveryLocks.length){throw failure('RECOVERY journal removal refused','EACCES');}return rmJournal.call(fs,target,...args);};" : ''} +${releaseFailure ? "const lstat=fs.lstatSync;fs.lstatSync=function(target,...args){if(target===path.join(dir,'.lock') && state.primary && state.recoveryLocks.length && !fs.existsSync(path.join(dir,'.txn'))){throw failure('RELEASE ownership read refused','EACCES');}return lstat.call(fs,target,...args);};" : ''} +${cleanupFailure ? "const rm=fs.rmSync;fs.rmSync=function(target,...args){if(target===path.join(dir,'.txn') && state.published===2 && fs.existsSync(target) && !fs.existsSync(path.join(dir,'.txn','journal.json'))){state.cleanup=true;save();throw failure('CLEANUP committed directory refused','EACCES');}return rm.call(fs,target,...args);};" : ''} +`); + return file; +} +function restored(f) { + assert.deepEqual(snapshot(path.join(f.root, '.stories')), f.before, 'every prior byte and new-file absence must match'); + assert.deepEqual(snapshot(path.join(f.root, '.git/story-lifecycle')), f.registryBefore); + const state = ok(run(f.root, ['status']));assert.equal(state.recoveryPending, false);assert.equal(state.projectionAvailable, undefined); + assert.deepEqual(state.drift, []); +} +const tests = [ + ['journal removal failure leaves restored bytes and a retryable journal', () => { + const f = fixture(true);const result = run(f.root, ['apply', '--input', f.file], fault(f.root, { journalRemovalFailure: true })); + assert.equal(result.status, 1);assert.match(result.stderr, /PRIMARY ordinary second publication/);assert.match(result.stderr, /RECOVERY journal removal refused/);assert.match(result.stderr, /recovery pending/i); + const current = snapshot(path.join(f.root, '.stories'));const { '.txn': transaction, ...data } = current;assert.ok(transaction['journal.json']);assert.deepEqual(data, f.before); + assert.equal(ok(run(f.root, ['status'])).recoveryPending, true);ok(run(f.root, ['recover']));restored(f); + }], + ['release failure preserves the primary error after successful rollback and permits stale-lock recovery', () => { + const f = fixture(true);const result = run(f.root, ['apply', '--input', f.file], fault(f.root, { releaseFailure: true })); + assert.equal(result.status, 1);assert.match(result.stderr, /PRIMARY ordinary second publication/);assert.match(result.stderr, /RELEASE ownership read refused/); + const { '.lock': lock, ...data } = snapshot(path.join(f.root, '.stories'));assert.ok(lock);assert.deepEqual(data, f.before); + ok(run(f.root, ['recover']));restored(f); + }], + ['failure after the committed journal marker does not undo a completed update', () => { + const f = fixture(true);const result = run(f.root, ['apply', '--input', f.file], fault(f.root, { cleanupFailure: true })); + assert.equal(result.status, 1);assert.match(result.stderr, /CLEANUP committed directory refused/); + for (const id of f.ids) assert.equal(fs.readFileSync(path.join(f.root, '.stories', `${id}.md`), 'utf8'), story(id, 'in-progress')); + assert.ok(!fs.existsSync(path.join(f.root, '.stories/.txn/journal.json'))); + assert.ok(!fs.existsSync(path.join(f.root, '.stories/.lock'))); + const trace = JSON.parse(fs.readFileSync(path.join(f.root, 'trace.json')));assert.equal(trace.published, 2);assert.deepEqual(trace.recoveryLocks, []); + ok(run(f.root, ['recover']));assert.deepEqual(ok(run(f.root, ['status'])).drift, []); + for (const id of f.ids) assert.equal(fs.readFileSync(path.join(f.root, '.stories', `${id}.md`), 'utf8'), story(id, 'in-progress')); + }], + ['crash70 preserves the pending journal for explicit recovery', () => { + const f = fixture();const preload = path.join(f.root, 'crash.cjs');fs.writeFileSync(preload, "process.env.STORY_LEDGER_CRASH_AFTER='1';"); + assert.equal(run(f.root, ['apply', '--input', f.file], preload).status, 70); + assert.ok(fs.existsSync(path.join(f.root, '.stories/.txn/journal.json'))); + ok(run(f.root, ['recover']));restored(f); + }], + ...[false, true].map(update => [`ordinary second ${update ? 'rename/update' : 'link/create'} failure restores the entire batch before returning`, () => { + const f = fixture(update);const result = run(f.root, ['apply', '--input', f.file], fault(f.root, { update })); + assert.equal(result.status, 1);assert.match(result.stderr, /PRIMARY ordinary second publication/); + const trace = JSON.parse(fs.readFileSync(path.join(f.root, 'trace.json')));assert.equal(trace.published, 1);assert.equal(trace.lock.pid > 0, true); + if (update) { assert.notEqual(trace.firstBytes, f.before['auth-1.md']);assert.ok(trace.recoveryLocks.length > 0);assert.ok(trace.recoveryLocks.every(Boolean)); } + else assert.ok(trace.firstBytes); + assert.ok(trace.recoveryLocks.length > 0);assert.ok(trace.recoveryLocks.every(Boolean)); + restored(f); + }]), + ['rollback failure reports both errors, retains journal, and explicit retry restores all bytes', () => { + const f = fixture(true);const result = run(f.root, ['apply', '--input', f.file], fault(f.root, { recoveryFailure: true })); + assert.equal(result.status, 1);assert.match(result.stderr, /PRIMARY ordinary second publication/);assert.match(result.stderr, /RECOVERY backup restore refused/);assert.match(result.stderr, /recovery pending/i); + assert.ok(fs.existsSync(path.join(f.root, '.stories/.txn/journal.json')));assert.ok(!fs.existsSync(path.join(f.root, '.stories/.lock'))); + const trace = JSON.parse(fs.readFileSync(path.join(f.root, 'trace.json')));assert.ok(trace.recoveryLocks.length > 0);assert.ok(trace.recoveryLocks.every(Boolean)); + assert.equal(ok(run(f.root, ['status'])).recoveryPending, true);ok(run(f.root, ['recover']));restored(f); + }], +]; +let passed = 0;let failed = 0; +for (const [name, test] of tests) { + try { test();console.log(`PASS ${name}`);passed++; } catch (error) { console.log(`FAIL ${name}: ${error.stack}`);failed++; } + finally { for (const dir of temps) fs.rmSync(dir, { recursive: true, force: true });temps.clear(); } +} +console.log(`Passed: ${passed}\nFailed: ${failed}`);process.exitCode = failed ? 1 : 0; diff --git a/tests/docs/story-lifecycle-table-projection.test.js b/tests/docs/story-lifecycle-table-projection.test.js new file mode 100644 index 000000000..893949a1d --- /dev/null +++ b/tests/docs/story-lifecycle-table-projection.test.js @@ -0,0 +1,186 @@ +const assert = require('assert'); +const fs = require('fs'); +const os = require('os'); +const path = require('path'); +const { execFileSync, spawnSync } = require('child_process'); + +const LEDGER = path.join(__dirname, '..', '..', 'skills', 'story-lifecycle', 'scripts', 'ledger.js'); +const MARKER = ''; +const EPIC_HEADER = '| ID | Title | Status |\n| --- | --- | --- |'; +const SPRINT_HEADER = '| ID | Title | Points | Status |\n| --- | --- | --- | --- |'; +const PREFIX = '# Epic: Auth flow\n\nUser introduction stays here.\n\n'; +const SUFFIX = '\n## Notes\n\nKeep this user prose byte for byte.\n'; +const ownedTemps = new Set(); + +function run(root, args) { + const result = spawnSync(process.execPath, [LEDGER, ...args, '--root', root], { + encoding: 'utf8', timeout: 10000, + }); + assert.strictEqual(result.status, 0, result.stderr || result.error?.message); + return JSON.parse(result.stdout); +} + +function read(root, rel) { + return fs.readFileSync(path.join(root, '.stories', rel), 'utf8'); +} + +function write(root, rel, text) { + fs.writeFileSync(path.join(root, '.stories', rel), text); +} + +function apply(root, changes) { + const input = path.join(root, 'changes.json'); + fs.writeFileSync(input, JSON.stringify(changes)); + return run(root, ['apply', '--input', input]); +} + +function newRepo() { + const root = fs.mkdtempSync(path.join(os.tmpdir(), 'story-table-projection-')); + ownedTemps.add(root); + execFileSync('git', ['init', '-q', root]); + run(root, ['init']); + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${EPIC_HEADER}\n`); + return root; +} + +function story(id, status = 'todo', sprint = 'unassigned') { + return `# Story: Sign in\n\n**ID:** ${id}\n**Epic:** auth-flow\n**Sprint:** ${sprint}\n**Status:** ${status}\n**Points:** 3\n`; +} + +function assertStable(root, rel, expected) { + assert.strictEqual(read(root, rel), expected); + assert.deepStrictEqual(run(root, ['status']).drift, []); + assert.deepStrictEqual(run(root, ['reconcile']).written, []); + assert.strictEqual(read(root, rel), expected); + assert.ok(!fs.existsSync(path.join(root, '.stories', '.txn'))); + assert.ok(!fs.existsSync(path.join(root, '.stories', '.lock'))); +} + +const tests = [ + ...['Sign in | recover', String.raw`Sign\|in | recover`].flatMap(title => ['apply', 'reconcile'].map(command => [ + `${command} preserves title table boundaries for ${JSON.stringify(title)}`, () => { + const root = newRepo();const [id] = run(root, ['allocate', '--epic', 'auth-flow']).ids; + write(root, 'sprints/sprint-1.md', `# Sprint 1\n\n${MARKER}\n${SPRINT_HEADER}\n\n## Total Points: 0\n`); + const raw = story(id, 'todo', '1').replace('Sign in', title); + if (command === 'apply') apply(root, { create: { [`${id}.md`]: raw } }); + else { apply(root, { create: { [`${id}.md`]: story(id, 'todo', '1') } });write(root, `${id}.md`, raw);run(root, ['reconcile']); } + const cell = title === 'Sign in | recover' ? String.raw`Sign in \| recover` : String.raw`Sign\\\|in \| recover`; + assert.ok(read(root, 'epics/auth-flow.md').includes(`| ${id} | ${cell} | todo |\n`)); + assert.ok(read(root, 'sprints/sprint-1.md').includes(`| ${id} | ${cell} | 3 | todo |\n`)); + assert.equal(read(root, `${id}.md`), raw, 'source title bytes stay unchanged'); + assertStable(root, 'epics/auth-flow.md', read(root, 'epics/auth-flow.md')); + assertStable(root, 'sprints/sprint-1.md', read(root, 'sprints/sprint-1.md')); + }, + ])), + ...['epic', 'sprint'].flatMap(kind => ['apply', 'reconcile'].flatMap(command => ['', '\n'].map(gap => [ + `${command} preserves a handwritten ${kind} table below an empty marker with gap ${JSON.stringify(gap)}`, () => { + const root = newRepo();const rel = kind === 'epic' ? 'epics/auth-flow.md' : 'sprints/sprint-1.md'; + const prefix = kind === 'epic' ? PREFIX : '# Sprint 1\n\n'; + const handwritten = '| Owner | Note |\n| --- | --- |\n| User | Keep every byte |\n'; + const suffix = `${gap}${handwritten}${SUFFIX}${kind === 'sprint' ? '\n## Total Points: 0\n' : ''}`; + write(root, rel, `${prefix}${MARKER}\n${suffix}`); + if (command === 'apply') { + const [id] = run(root, ['allocate', '--epic', 'auth-flow']).ids; + apply(root, { create: { [`${id}.md`]: story(id) } }); + } else run(root, ['reconcile']); + const actual = read(root, rel);assert.ok(actual.endsWith(suffix), 'handwritten table and prose must remain byte-identical'); + assert.equal(actual.split(handwritten).length, 2);assertStable(root, rel, actual); + }, + ]))), + ['an unrelated table immediately after derived rows survives repeat transitions', () => { + const root = newRepo();const [id] = run(root, ['allocate', '--epic', 'auth-flow']).ids; + const user = '| Owner | Note |\n| --- | --- |\n| User | Keep |\n'; + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${EPIC_HEADER}\n${user}${SUFFIX}`); + apply(root, { create: { [`${id}.md`]: story(id) } }); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${EPIC_HEADER}\n| ${id} | Sign in | todo |\n${user}${SUFFIX}`); + }], + ['an EOF marker without a newline appends its table after the marker', () => { + const root = newRepo(); + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}`); + const [id] = run(root, ['allocate', '--epic', 'auth-flow']).ids; + apply(root, { create: { [`${id}.md`]: story(id) } }); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${EPIC_HEADER}\n| ${id} | Sign in | todo |\n`); + }], + ['an empty EOF marker with trailing spaces remains after user prose', () => { + const root = newRepo(); + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER} `); + run(root, ['reconcile']); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER} \n${EPIC_HEADER}\n`); + }], + ...['\n', ' \t\n\n', '\r\n \t\r\n'].map(gap => [ + `blank whitespace ${JSON.stringify(gap)} before an epic table is preserved without duplicates`, () => { + const root = newRepo(); + const [id] = run(root, ['allocate', '--epic', 'auth-flow']).ids; + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${gap}${EPIC_HEADER}\n| stale-99 | Old row | done |\n${SUFFIX}`); + apply(root, { create: { [`${id}.md`]: story(id) } }); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${gap}${EPIC_HEADER}\n| ${id} | Sign in | todo |\n${SUFFIX}`); + }, + ]), + ['a sprint transition replaces a whitespace-separated table and updates total points', () => { + const root = newRepo(); + const [id] = run(root, ['allocate', '--epic', 'auth-flow']).ids; + const prefix = `# Sprint 1\n\n${MARKER}\n \t\n`; + const suffix = `\n## Total Points: 99\n${SUFFIX}`; + apply(root, { create: { [`${id}.md`]: story(id), + 'sprints/sprint-1.md': `${prefix}${SPRINT_HEADER}\n| stale-99 | Old row | 99 | done |\n${suffix}` } }); + apply(root, { update: { [`${id}.md`]: story(id, 'in-progress', '1') } }); + assertStable(root, 'sprints/sprint-1.md', `${prefix}${SPRINT_HEADER}\n| ${id} | Sign in | 3 | in-progress |\n${suffix.replace('99', '3')}`); + }], + ['reconciliation removes consecutive stale copies of the same derived table', () => { + const root = newRepo(); + const [id] = run(root, ['allocate', '--epic', 'auth-flow']).ids; + apply(root, { create: { [`${id}.md`]: story(id) } }); + const current = `${EPIC_HEADER}\n| ${id} | Sign in | todo |\n`; + const stale = '|ID|Title|Status|\n|---|---|---|\n| stale-99 | Old row | done |\n'; + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${current}\n ${'\t'}\n${stale}\n${stale}${SUFFIX}`); + assert.deepStrictEqual(run(root, ['status']).drift, ['epics/auth-flow.md']); + run(root, ['reconcile']); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${current}${SUFFIX}`); + }], + ['unrelated tables and a later table after prose stay byte-identical', () => { + const root = newRepo(); + const [id] = run(root, ['allocate', '--epic', 'auth-flow']).ids; + const userTables = `\n| Owner | Note |\n| --- | --- |\n| User | Keep |\n${SUFFIX}\n${EPIC_HEADER}\n| example-1 | User example | done |\n`; + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${EPIC_HEADER}\n${userTables}`); + apply(root, { create: { [`${id}.md`]: story(id) } }); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${EPIC_HEADER}\n| ${id} | Sign in | todo |\n${userTables}`); + }], + ['a stale table ending at EOF is replaced without adding another table', () => { + const root = newRepo(); + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n\n${EPIC_HEADER}\n| stale-99 | Old row | done |`); + run(root, ['reconcile']); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n\n${EPIC_HEADER}\n`); + }], + ['the initial derived table can use compact Markdown header spacing', () => { + const root = newRepo(); + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n \t\n|ID|Title|Status|\n|---|---|---|\n|stale-99|Old row|done|\n${SUFFIX}`); + run(root, ['reconcile']); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n \t\n${EPIC_HEADER}\n${SUFFIX}`); + }], + ['inserting a missing table leaves blank lines and following prose intact', () => { + const root = newRepo(); + const suffix = ` \t\n\n${SUFFIX}`; + write(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${suffix}`); + run(root, ['reconcile']); + assertStable(root, 'epics/auth-flow.md', `${PREFIX}${MARKER}\n${EPIC_HEADER}\n${suffix}`); + }], +]; + +let passed = 0; +let failed = 0; +console.log('\n=== Testing story-lifecycle table projection workflows ===\n'); +for (const [name, test] of tests) { + try { + test(); + console.log(` ✓ ${name}`); + passed++; + } catch (error) { + console.log(` ✗ ${name}\n Error: ${error.message}`); + failed++; + } finally { + for (const dir of ownedTemps) fs.rmSync(dir, { recursive: true, force: true }); + ownedTemps.clear(); + } +} +console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`); +process.exitCode = failed > 0 ? 1 : 0; diff --git a/tests/hooks/ecc-statusline-project-plugins.test.js b/tests/hooks/ecc-statusline-project-plugins.test.js new file mode 100644 index 000000000..a9bfb5d48 --- /dev/null +++ b/tests/hooks/ecc-statusline-project-plugins.test.js @@ -0,0 +1,55 @@ +'use strict'; +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const { spawnSync } = require('node:child_process'); +const { readInstalledPlugins } = require('../../scripts/lib/statusline-render'); +const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-plugin-project-')); +const config = path.join(root, 'profile');const a = path.join(root, 'A');const b = path.join(root, 'B'); +for (const dir of [config, a, b]) fs.mkdirSync(path.join(dir, '.claude'), { recursive: true }); +fs.mkdirSync(path.join(config, 'plugins')); +const records = { 'a-only@fixture': [{ scope: 'local', projectPath: a, version: '9.9.9' }], + 'shared@fixture': [{ scope: 'project', projectPath: a, version: '1.1.0' }, { scope: 'project', projectPath: b, version: '2.2.0' }, { scope: 'user', version: '0.0.1' }], + 'global@fixture': [{ scope: 'user', version: '3.3.3' }] }; +const write = value => fs.writeFileSync(path.join(config, 'plugins/installed_plugins.json'), JSON.stringify({ version: 2, plugins: value })); +const settings = (dir, name, value) => fs.writeFileSync(path.join(dir, '.claude', name), JSON.stringify({ enabledPlugins: value })); +function cli(project) { + const result = spawnSync(process.execPath, [path.resolve(__dirname, '../../scripts/hooks/ecc-statusline.js')], { + input: JSON.stringify({ model: { display_name: 'Fixture' }, workspace: { current_dir: project } }), encoding: 'utf8', timeout: 5000, + env: { ...process.env, CLAUDE_CONFIG_DIR: config, ECC_STATUSLINE_USAGE: '1', ECC_STATUSLINE_COMPACT: '0' }, + });assert.equal(result.status, 0, result.stderr);return result.stdout; +} +const tests = [ + ['actual B statusline excludes A-only plugins and selects B shared version independent of record order', () => { + write(records);const first = cli(b);assert.doesNotMatch(first, /a-only|1\.1\.0/);assert.match(first, /shared.*2\.2\.0/); + write({ ...records, 'shared@fixture': [...records['shared@fixture']].reverse() });assert.equal(cli(b), first); + }], + ['project A gets its applicable local and shared records', () => { write(records);const output = cli(a);assert.match(output, /a-only.*9\.9\.9/);assert.match(output, /shared.*1\.1\.0/); }], + ['project settings disable a user-enabled plugin in the real statusline', () => { + write(records);fs.writeFileSync(path.join(config, 'settings.json'), JSON.stringify({ enabledPlugins: { 'global@fixture': true } })); + settings(b, 'settings.json', { 'global@fixture': false });assert.doesNotMatch(cli(b), /global/); + }], + ['local settings override shared project settings without changing their bytes', () => { + settings(b, 'settings.local.json', { 'global@fixture': true });const file = path.join(b, '.claude/settings.json');const before = fs.readFileSync(file);assert.match(cli(b), /global/);assert.deepEqual(fs.readFileSync(file), before); + }], + ['applicable local version overrides project and user records', () => { + write({ ...records, 'shared@fixture': [...records['shared@fixture'], { scope: 'local', projectPath: b, version: '4.4.4' }] }); + assert.equal(readInstalledPlugins(config, b).find(x => x.name === 'shared').version, '4.4.4'); + }], + ['nested Git workspaces use the project inventory and local settings', () => { + require('node:child_process').execFileSync('git', ['init', '-q', b]); + const nested = path.join(b, 'src');fs.mkdirSync(nested); + write(records);settings(b, 'settings.local.json', { 'global@fixture': false }); + const output = cli(nested);assert.match(output, /shared.*2\.2\.0/);assert.doesNotMatch(output, /global|a-only/); + }], + ['a similarly named sibling path does not inherit B-scoped installations', () => { + const sibling = path.join(root, 'B-other');fs.mkdirSync(sibling);write(records); + const plugins = readInstalledPlugins(config, sibling);assert.equal(plugins.find(x => x.name === 'shared').version, '0.0.1');assert.ok(!plugins.some(x => x.name === 'a-only')); + }], +]; +let passed = 0;let failed = 0; +try { + for (const [name, test] of tests) { try { test();console.log(`PASS ${name}`);passed++; } catch (error) { console.log(`FAIL ${name}: ${error.stack}`);failed++; } } +} finally { fs.rmSync(root, { recursive: true, force: true }); } +console.log(`Passed: ${passed}\nFailed: ${failed}`);process.exitCode = failed ? 1 : 0; diff --git a/tests/hooks/observe-secret-redaction-environment.test.js b/tests/hooks/observe-secret-redaction-environment.test.js index 5610bc4aa..872d15e81 100644 --- a/tests/hooks/observe-secret-redaction-environment.test.js +++ b/tests/hooks/observe-secret-redaction-environment.test.js @@ -6,6 +6,8 @@ const os = require('node:os'); const path = require('node:path'); const { spawnSync } = require('node:child_process'); +let passed = 0; +let failed = 0; if (process.platform === 'win32') { console.log('Skipping non-Windows Python availability control.'); } else { @@ -19,7 +21,14 @@ if (process.platform === 'win32') { assert.match(result.stdout, /Passed: 0\nFailed: 1/); assert.doesNotMatch(result.stdout, /Skipping shell fixtures/); console.log('PASS missing Python fails the actual non-Windows redaction gate'); + passed += 1; + } catch (error) { + console.log(`FAIL ${error.message}`); + failed += 1; } finally { fs.rmSync(emptyPath, { recursive: true, force: true }); } } +console.log(`Passed: ${passed}`); +console.log(`Failed: ${failed}`); +process.exitCode = failed ? 1 : 0; diff --git a/tests/lib/command-plugin-root.test.js b/tests/lib/command-plugin-root.test.js index 0e7295dbf..73cb1cf11 100644 --- a/tests/lib/command-plugin-root.test.js +++ b/tests/lib/command-plugin-root.test.js @@ -115,7 +115,7 @@ for (const name of ['auto-update', 'instinct-status', 'skill-health', 'skill-hos try { const selected = { ...process.env, HOME: temp, USERPROFILE: temp, CLAUDE_CONFIG_DIR: root }; delete selected.CLAUDE_PLUGIN_ROOT; - for (const env of [selected, { ...selected, CLAUDE_PLUGIN_ROOT: root }]) { + for (const env of [selected, { ...selected, CLAUDE_PLUGIN_ROOT: root }, { ...selected, CLAUDE_PLUGIN_ROOT: ' \t ' }, { ...selected, CLAUDE_PLUGIN_ROOT: ` ${root} ` }]) { const [bash] = resolveWindowsBashCandidates(['bash.exe', 'bash'], { env }); const shell = process.platform === 'win32' ? bash : 'bash'; assert.ok(shell, 'A native Git Bash executable is required'); @@ -129,6 +129,63 @@ for (const name of ['auto-update', 'instinct-status', 'skill-health', 'skill-hos }); } } +for (const broken of [false, true]) { + test(`auto-update legacy-only cache ${broken ? 'rejects corrupt current cache before follow-up' : 'runs the actual selected updater'}`, () => { + const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-legacy-update-')); + try { + const root = path.join(temp, 'plugins/cache/everything-claude-code/vendor/1.0.0'); + fs.mkdirSync(path.join(root, 'scripts/lib'), { recursive: true }); + fs.mkdirSync(path.join(root, ECC_SKILL_SENTINEL), { recursive: true }); + fs.copyFileSync(path.join(__dirname, '../../scripts/lib/resolve-ecc-root.js'), path.join(root, 'scripts/lib/resolve-ecc-root.js')); + fs.writeFileSync(path.join(root, 'scripts/lib/utils.js'), '// fixture'); + fs.writeFileSync(path.join(root, 'scripts/auto-update.js'), "console.log('UPDATER:'+__dirname+':'+process.argv.slice(2).join(','))"); + if (broken) fs.writeFileSync(path.join(temp, 'plugins/cache/ecc'), 'occupied non-directory'); + const env = { ...process.env, HOME: temp, USERPROFILE: temp, CLAUDE_CONFIG_DIR: temp }; + delete env.CLAUDE_PLUGIN_ROOT; + const [bash] = resolveWindowsBashCandidates(['bash.exe', 'bash'], { env }); + const shell = process.platform === 'win32' ? bash : 'bash'; + const doc = fs.readFileSync(path.join(__dirname, '../../commands/auto-update.md'), 'utf8'); + const assignment = doc.split('\n').find(line => line.startsWith('ECC_ROOT=')); + const followup = broken ? 'node -e "console.log(\'FOLLOWUP_INVOKED\')"' : 'node "$ECC_ROOT/scripts/auto-update.js" --dry-run'; + const result = spawnSync(shell, ['-s'], { input: assignment + '\n' + followup + '\n', env, cwd: temp, encoding: 'utf8' }); + const { resolveEccRoot } = require('../../scripts/lib/resolve-ecc-root'); + const options = { envRoot: '', configDir: temp, probe: path.join('scripts', 'auto-update.js') }; + if (broken) { + assert.equal(result.status, 1);assert.match(result.stderr, /ENOTDIR/);assert.equal(result.stdout, ''); + assert.throws(() => resolveEccRoot(options), error => error.code === 'ENOTDIR'); + } else { + assert.equal(result.status, 0, result.stderr);assert.equal(result.stdout.trim(), `UPDATER:${fs.realpathSync(path.join(root, 'scripts'))}:--dry-run`); + assert.equal(resolveEccRoot(options), root); + } + } finally { fs.rmSync(temp, { recursive: true, force: true }); } + }); +} +for (const level of ['slug', 'org']) { + test(`actual command skips non-directory cache children at ${level} level`, () => { + const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-stray-cache-')); + try { + const root = path.join(temp, 'plugins/cache/everything-claude-code/vendor/1.0.0'); + fs.mkdirSync(path.join(root, 'scripts/lib'), { recursive: true }); + fs.mkdirSync(path.join(root, ECC_SKILL_SENTINEL), { recursive: true }); + fs.copyFileSync(path.join(__dirname, '../../scripts/lib/resolve-ecc-root.js'), path.join(root, 'scripts/lib/resolve-ecc-root.js')); + fs.writeFileSync(path.join(root, 'scripts/lib/utils.js'), '// fixture'); + fs.writeFileSync(path.join(root, 'scripts/auto-update.js'), "console.log('UPDATER:'+__dirname)"); + const cache = path.join(temp, 'plugins/cache/ecc'); + const strayDir = level === 'slug' ? cache : path.join(cache, 'vendor'); + fs.mkdirSync(strayDir, { recursive: true }); + fs.writeFileSync(path.join(strayDir, 'stray.txt'), 'preserve'); + const env = { ...process.env, HOME: temp, USERPROFILE: temp, CLAUDE_CONFIG_DIR: temp }; + delete env.CLAUDE_PLUGIN_ROOT; + const [bash] = resolveWindowsBashCandidates(['bash.exe', 'bash'], { env }); + const shell = process.platform === 'win32' ? bash : 'bash'; + const assignment = fs.readFileSync(path.join(__dirname, '../../commands/auto-update.md'), 'utf8').split('\n').find(line => line.startsWith('ECC_ROOT=')); + const result = spawnSync(shell, ['-s'], { input: assignment + '\nnode "$ECC_ROOT/scripts/auto-update.js"\n', env, cwd: temp, encoding: 'utf8' }); + assert.equal(result.status, 0, result.stderr); + assert.equal(result.stdout.trim(), `UPDATER:${fs.realpathSync(path.join(root, 'scripts'))}`); + assert.equal(fs.readFileSync(path.join(strayDir, 'stray.txt'), 'utf8'), 'preserve'); + } finally { fs.rmSync(temp, { recursive: true, force: true }); } + }); +} console.log(`Passed: ${passed}`); console.log(`Failed: ${failed}`); diff --git a/tests/lib/eval-harness/cli.test.js b/tests/lib/eval-harness/cli.test.js index e552da166..fbfd7bf4a 100644 --- a/tests/lib/eval-harness/cli.test.js +++ b/tests/lib/eval-harness/cli.test.js @@ -8,7 +8,9 @@ const vm = require('vm'); const { test, tempDir, cleanup, finish } = require('./helpers'); const harness = require('../../../scripts/lib/eval-harness'); const cli = path.resolve(__dirname, '../../../scripts/eval-harness.js'); -const run = args => spawnSync(process.execPath, [cli, ...args], { encoding: 'utf8', timeout: 3000 }); +// Allow bounded process startup under loaded native runners; still fail hangs. +const CLI_TIMEOUT_MS = 15000; +const run = args => spawnSync(process.execPath, [cli, ...args], { encoding: 'utf8', timeout: CLI_TIMEOUT_MS }); // Exercise spawn failures without starting an example, mutating the real // process object, or depending on a host-specific missing executable. @@ -76,13 +78,28 @@ test('dangling receipt value flags are usage errors before reading missing input for (const flag of ['--artifact', '--gate', '--out']) { for (const tail of [[flag], [flag, '--artifact']]) { const result = run([...command, ...tail]); - assert.strictEqual(result.status, 2, `${tail}: ${result.stderr}`); + assert.strictEqual(result.status, 2, `${tail}: ${result.error?.code || result.signal || result.stderr}`); assert.match(result.stderr, /needs a value/); } } } }); +test('usage validation survives a bounded slow child startup', () => { + const dir = tempDir('cli-slow-start'); + try { + const preload = path.join(dir, 'startup-delay.cjs'); + fs.writeFileSync(preload, 'Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 3500);\n'); + const result = spawnSync(process.execPath, ['--require', preload, cli, + 'receipt', 'verify', '/absent-receipt', '/absent-capsule', '--out'], { + encoding: 'utf8', timeout: CLI_TIMEOUT_MS, + }); + assert.strictEqual(result.status, 2, result.error?.code || result.signal || result.stderr); + assert.strictEqual(result.stdout, ''); + assert.match(result.stderr, /needs a value/); + } finally { cleanup(dir); } +}); + test('invalid output flag does not cause producer projection writes', () => { const dir = tempDir('cli-build'); try { diff --git a/tests/lib/gateguard-search-evidence.test.js b/tests/lib/gateguard-search-evidence.test.js index a39e56e6f..7045359c4 100644 --- a/tests/lib/gateguard-search-evidence.test.js +++ b/tests/lib/gateguard-search-evidence.test.js @@ -233,6 +233,22 @@ test('a search confined to the target file name is a lookup, not a search', () = assert.strictEqual((findClosestMiss(lookupOfModule, testTarget, false, data) || {}).reason, 'excluded'); }); +test('PowerShell single-quoted backslash filters preserve inclusion and exclusion scope', () => { + const { findCreditingSearch, findClosestMiss } = loadHook(); + const target = String.raw`C:\repo\src\lexer\handler.py`; + const data = { cwd: String.raw`C:\repo` }; + for (const command of [String.raw`rg -g 'src\lexer\*.py' handler .`, String.raw`rg handler src\lexer`]) { + assert.ok(findCreditingSearch(filterScan([filterSearch('PowerShell', { command })]), target, false, data), command); + } + const command = String.raw`rg -g '!src\lexer\*.py' handler .`; + const scan = filterScan([filterSearch('PowerShell', { command })]); + assert.equal(findCreditingSearch(scan, target, false, data), null); + assert.equal(findClosestMiss(scan, target, false, data).reason, 'excluded'); + const ambiguous = String.raw`rg -g 'src''\lexer\*.py' handler .`; + assert.equal(findCreditingSearch(filterScan([filterSearch('PowerShell', { command: ambiguous })]), target, false, data), null, + 'unsupported PowerShell literal-apostrophe syntax must never credit a different path'); +}); + fs.rmSync(transcriptDir, { recursive: true, force: true }); console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`); diff --git a/tests/lib/skill-evolution-storage.test.js b/tests/lib/skill-evolution-storage.test.js new file mode 100644 index 000000000..430c0da7c --- /dev/null +++ b/tests/lib/skill-evolution-storage.test.js @@ -0,0 +1,423 @@ +'use strict'; + +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const versioning = require('../../scripts/lib/skill-evolution/versioning'); +const health = require('../../scripts/lib/skill-evolution/health'); + +let passed = 0; +let failed = 0; + +function createFixture() { + const root = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-evolution-storage-')); + const skillDir = path.join(root, 'skills', 'demo'); + fs.mkdirSync(skillDir, { recursive: true }); + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Original\n'); + return { root, skillDir, versionsDir: versioning.getVersionsDir(skillDir) }; +} + +function test(name, fn) { + const fixture = createFixture(); + try { + fn(fixture); + passed += 1; + console.log(` ✓ ${name}`); + } catch (error) { + failed += 1; + console.error(` ✗ ${name}: ${error.message}`); + } finally { + fs.rmSync(fixture.root, { recursive: true, force: true }); + } +} + +test('snapshot creation preserves occupied directories and links plus earlier snapshots', fixture => { + const { root, skillDir, versionsDir } = fixture; + versioning.createVersion(skillDir); + fs.mkdirSync(path.join(versionsDir, 'v2.md')); + fs.writeFileSync(path.join(versionsDir, 'v2.md', 'keep.txt'), 'preserve'); + if (process.platform !== 'win32') { + fs.symlinkSync(path.join(root, 'missing'), path.join(versionsDir, 'v3.md')); + } + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Updated\n'); + const snapshot = versioning.createVersion(skillDir); + assert.equal(snapshot.version, process.platform === 'win32' ? 3 : 4); + assert.equal(fs.readFileSync(snapshot.path, 'utf8'), '# Updated\n'); + assert.equal(fs.readFileSync(path.join(versionsDir, 'v1.md'), 'utf8'), '# Original\n'); + assert.equal(fs.readFileSync(path.join(versionsDir, 'v2.md', 'keep.txt'), 'utf8'), 'preserve'); + assert.equal(versioning.getEvolutionLog(skillDir, 'amendments').at(-1).version, snapshot.version); + if (process.platform !== 'win32') { + assert.ok(fs.lstatSync(path.join(versionsDir, 'v3.md')).isSymbolicLink()); + fs.symlinkSync(path.join(versionsDir, 'v1.md'), path.join(versionsDir, 'v5.md')); + assert.deepEqual(versioning.listVersions(skillDir).map(entry => entry.version), [1, 4, 5]); + assert.equal(versioning.getCurrentVersion(skillDir), 5); + } +}); + +test('health skips malformed amendment rows while retaining a valid pending proposal', fixture => { + const { root, skillDir } = fixture; + versioning.ensureSkillVersioning(skillDir); + fs.writeFileSync(versioning.getEvolutionLogPath(skillDir, 'amendments'), + 'null\n[]\n42\n{bad}\n{"event":"proposal","status":"pending"}\n'); + const report = health.collectSkillHealth({ + skillsRoot: path.join(root, 'skills'), homeDir: root, now: '2026-03-15T12:00:00.000Z', + }); + assert.equal(report.skills.find(skill => skill.skill_id === 'demo').pending_amendments, 1); +}); + +test('snapshot allocation ignores invalid numeric names and preserves their contents', fixture => { + const { skillDir, versionsDir } = fixture; + fs.mkdirSync(versionsDir); + const names = ['v0.md', 'v9007199254740992.md', `v${'9'.repeat(80)}.md`]; + for (const name of names) fs.writeFileSync(path.join(versionsDir, name), 'preserve'); + assert.deepEqual(versioning.listVersions(skillDir), []); + const snapshot = versioning.createVersion(skillDir); + assert.equal(snapshot.version, 1); + assert.equal(fs.readFileSync(snapshot.path, 'utf8'), '# Original\n'); + for (const name of names) assert.equal(fs.readFileSync(path.join(versionsDir, name), 'utf8'), 'preserve'); +}); + +test('exhausted snapshot numbering refuses creation before initializing evolution logs', fixture => { + const { skillDir, versionsDir } = fixture; + fs.mkdirSync(versionsDir); + const last = path.join(versionsDir, `v${Number.MAX_SAFE_INTEGER}.md`); + fs.writeFileSync(last, 'preserve'); + assert.throws(() => versioning.createVersion(skillDir), /snapshot version range is exhausted/); + assert.deepEqual(fs.readdirSync(versionsDir).sort(), [`v${Number.MAX_SAFE_INTEGER}.md`]); + assert.equal(fs.readFileSync(last, 'utf8'), 'preserve'); + assert.equal(fs.existsSync(versioning.getEvolutionDir(skillDir)), false); +}); + +test('an occupied final safe snapshot path refuses creation while preserving the directory', fixture => { + const { skillDir, versionsDir } = fixture; + fs.mkdirSync(versionsDir); + fs.writeFileSync(path.join(versionsDir, `v${Number.MAX_SAFE_INTEGER - 1}.md`), 'preserve'); + const occupied = path.join(versionsDir, `v${Number.MAX_SAFE_INTEGER}.md`); + fs.mkdirSync(occupied); + fs.writeFileSync(path.join(occupied, 'keep.txt'), 'preserve'); + assert.throws(() => versioning.createVersion(skillDir), /snapshot version range is exhausted/); + assert.equal(fs.readdirSync(versionsDir).length, 2); + assert.equal(fs.readFileSync(path.join(occupied, 'keep.txt'), 'utf8'), 'preserve'); + assert.equal(fs.existsSync(versioning.getEvolutionDir(skillDir)), false); +}); + +test('exhausted rollback preserves unsnapshotted content, snapshot files and evolution state', fixture => { + const { skillDir, versionsDir } = fixture; + fs.mkdirSync(versionsDir); + const previous = path.join(versionsDir, 'v1.md'); + const last = path.join(versionsDir, `v${Number.MAX_SAFE_INTEGER}.md`); + fs.writeFileSync(previous, '# Previous\n'); + fs.writeFileSync(last, '# Latest snapshot\n'); + const assertPreserved = () => { + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Original\n'); + assert.equal(fs.readFileSync(previous, 'utf8'), '# Previous\n'); + assert.equal(fs.readFileSync(last, 'utf8'), '# Latest snapshot\n'); + assert.equal(fs.readdirSync(versionsDir).length, 2); + }; + assert.throws(() => versioning.rollbackTo(skillDir, 1), /snapshot version range is exhausted/); + assertPreserved(); + assert.equal(fs.existsSync(versioning.getEvolutionDir(skillDir)), false); + versioning.ensureSkillVersioning(skillDir); + const logs = versioning.EVOLUTION_LOG_TYPES.map(type => versioning.getEvolutionLogPath(skillDir, type)); + for (const file of logs) fs.writeFileSync(file, '{"event":"preserve"}\n'); + assert.throws(() => versioning.rollbackTo(skillDir, 1), /snapshot version range is exhausted/); + assertPreserved(); + for (const file of logs) assert.equal(fs.readFileSync(file, 'utf8'), '{"event":"preserve"}\n'); +}); + +test('unsafe rollback targets preserve the live skill and excluded snapshots', fixture => { + const { skillDir, versionsDir } = fixture; + fs.mkdirSync(versionsDir); + const invalid = path.join(versionsDir, 'v9007199254740992.md'); + fs.writeFileSync(invalid, '# Excluded snapshot\n'); + for (const target of [9007199254740992, '9007199254740992']) { + assert.throws(() => versioning.rollbackTo(skillDir, target), /Invalid target version/); + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Original\n'); + assert.equal(fs.readFileSync(invalid, 'utf8'), '# Excluded snapshot\n'); + assert.equal(fs.readdirSync(versionsDir).length, 1); + assert.equal(fs.existsSync(versioning.getEvolutionDir(skillDir)), false); + } +}); + +test('rollback initialization failure preserves unsnapshotted live bytes and the target', fixture => { + const { skillDir, versionsDir } = fixture; + fs.mkdirSync(versionsDir); + const target = path.join(versionsDir, 'v1.md'); + fs.writeFileSync(target, '# Saved target\n'); + fs.writeFileSync(versioning.getEvolutionDir(skillDir), 'owned blocker'); + assert.throws(() => versioning.rollbackTo(skillDir, 1), error => Boolean(error.code)); + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Original\n'); + assert.equal(fs.readFileSync(target, 'utf8'), '# Saved target\n'); + assert.deepEqual(fs.readdirSync(versionsDir).sort(), ['v1.md']); + assert.equal(fs.readFileSync(versioning.getEvolutionDir(skillDir), 'utf8'), 'owned blocker'); +}); + +test('rollback exclusive publication failure preserves live bytes and permits a later retry', fixture => { + const { skillDir, versionsDir } = fixture; + versioning.createVersion(skillDir); + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Unsnapshotted work\n'); + const amendmentPath = versioning.getEvolutionLogPath(skillDir, 'amendments'); + const priorLog = fs.readFileSync(amendmentPath, 'utf8'); + const writeFileSync = fs.writeFileSync; + const injectedError = Object.assign(new Error('Injected snapshot publication failure'), { code: 'EIO' }); + fs.writeFileSync = (file, ...args) => { + if (typeof file === 'number' && args[0] === '# Original\n') throw injectedError; + return writeFileSync(file, ...args); + }; + try { + assert.throws(() => versioning.rollbackTo(skillDir, 1), error => error === injectedError); + } finally { + fs.writeFileSync = writeFileSync; + } + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Unsnapshotted work\n'); + assert.equal(fs.readFileSync(path.join(versionsDir, 'v1.md'), 'utf8'), '# Original\n'); + assert.deepEqual(fs.readdirSync(versionsDir).sort(), ['v1.md']); + assert.equal(fs.readFileSync(amendmentPath, 'utf8'), priorLog); + const restored = versioning.rollbackTo(skillDir, 1); + assert.equal(restored.version, 2); + assert.equal(fs.readFileSync(restored.path, 'utf8'), '# Original\n'); + assert.equal(fs.readFileSync(restored.path, 'utf8'), fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8')); + assert.equal(versioning.getEvolutionLog(skillDir, 'amendments').at(-1).event, 'rollback'); +}); + +test('failed live rollback write preserves version and applied history, then retries without a duplicate', fixture => { + const { root, skillDir, versionsDir } = fixture; + versioning.createVersion(skillDir); + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Unsnapshotted work\n'); + const logPath = versioning.getEvolutionLogPath(skillDir, 'amendments'); + const priorLog = fs.readFileSync(logPath, 'utf8'); + const writeFileSync = fs.writeFileSync; + const injectedError = Object.assign(new Error('Injected live write failure'), { code: 'EACCES' }); + fs.writeFileSync = (file, ...args) => { + if (file === path.join(skillDir, 'SKILL.md')) throw injectedError; + return writeFileSync(file, ...args); + }; + try { + assert.throws(() => versioning.rollbackTo(skillDir, 1), error => error === injectedError); + } finally { + fs.writeFileSync = writeFileSync; + } + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Unsnapshotted work\n'); + assert.deepEqual(fs.readdirSync(versionsDir).sort(), ['v1.md']); + assert.equal(versioning.getCurrentVersion(skillDir), 1); + assert.equal(fs.readFileSync(logPath, 'utf8'), priorLog); + const report = health.collectSkillHealth({ skillsRoot: path.join(root, 'skills'), homeDir: root }); + assert.equal(report.skills.find(skill => skill.skill_id === 'demo').current_version, 'v1'); + const restored = versioning.rollbackTo(skillDir, 1); + assert.equal(restored.version, 2); + assert.equal(fs.readFileSync(restored.path, 'utf8'), fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8')); + assert.equal(versioning.getEvolutionLog(skillDir, 'amendments').filter(row => row.event === 'rollback').length, 1); +}); + +test('failed rollback preserves a foreign snapshot replacement and both error details', fixture => { + const { skillDir, versionsDir } = fixture; + versioning.createVersion(skillDir); + const live = path.join(skillDir, 'SKILL.md'); + fs.writeFileSync(live, '# Unsnapshotted work\n'); + const target = path.join(versionsDir, 'v2.md'); + const writeFileSync = fs.writeFileSync; + const primary = Object.assign(new Error('Injected live refusal'), { code: 'EACCES' }); + fs.writeFileSync = (file, ...args) => { + if (file === live) { + fs.renameSync(target, path.join(versionsDir, 'owned-attempt.saved')); + writeFileSync(target, '# Foreign snapshot\n'); + throw primary; + } + return writeFileSync(file, ...args); + }; + try { + assert.throws(() => versioning.rollbackTo(skillDir, 1), error => + error.primaryError === primary && /changed ownership/.test(error.recoveryError.message) && /recovery is pending/.test(error.message)); + } finally { + fs.writeFileSync = writeFileSync; + } + assert.equal(fs.readFileSync(live, 'utf8'), '# Unsnapshotted work\n'); + assert.equal(fs.readFileSync(target, 'utf8'), '# Foreign snapshot\n'); + assert.equal(versioning.getEvolutionLog(skillDir, 'amendments').filter(row => row.event === 'rollback').length, 0); +}); + +test('descriptor metadata and final-link failures never expose an empty or incomplete version', fixture => { + const { skillDir, versionsDir } = fixture; + versioning.createVersion(skillDir); + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Unsnapshotted work\n'); + const logPath = versioning.getEvolutionLogPath(skillDir, 'amendments'); + const priorLog = fs.readFileSync(logPath, 'utf8'); + for (const operation of ['fstatSync', 'linkSync']) { + const original = fs[operation]; + const openSync = fs.openSync; + let publicationDescriptor; + let reachedPublication = false; + fs.openSync = (file, ...args) => { + const descriptor = openSync(file, ...args); + const directory = path.basename(path.dirname(file)); + if (directory.startsWith('.snapshot-') && !directory.startsWith('.snapshot-storage-')) publicationDescriptor = descriptor; + return descriptor; + }; + const injectedError = Object.assign(new Error(`Injected ${operation} failure`), { code: 'EIO' }); + fs[operation] = (...args) => { + if ((operation === 'fstatSync' && args[0] === publicationDescriptor) + || (operation === 'linkSync' && args[1] === path.join(versionsDir, 'v2.md'))) { + reachedPublication = true; + throw injectedError; + } + return original(...args); + }; + try { + assert.throws(() => versioning.rollbackTo(skillDir, 1), error => error === injectedError || (error.primaryError === injectedError && /recovery is pending/.test(error.message))); + } finally { + fs[operation] = original; + fs.openSync = openSync; + } + assert.equal(reachedPublication, true, `${operation} must fail publication after the storage probe succeeds`); + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Unsnapshotted work\n'); + assert.equal(fs.existsSync(path.join(versionsDir, 'v2.md')), false); + assert.deepEqual(versioning.listVersions(skillDir).map(row => row.version), [1]); + assert.equal(versioning.getCurrentVersion(skillDir), 1); + assert.equal(fs.readFileSync(logPath, 'utf8'), priorLog); + } + const restored = versioning.rollbackTo(skillDir, 1); + assert.equal(restored.version, 2); + assert.equal(fs.readFileSync(restored.path, 'utf8'), fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8')); +}); + +test('exclusive snapshot publication preserves a path occupied after allocation', fixture => { + const { skillDir, versionsDir } = fixture; + versioning.createVersion(skillDir); + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Unsnapshotted work\n'); + const target = path.join(versionsDir, 'v2.md'); + const linkSync = fs.linkSync; + fs.linkSync = (source, destination) => { + if (destination === target) fs.writeFileSync(target, '# Foreign snapshot\n', { flag: 'wx' }); + return linkSync(source, destination); + }; + try { + assert.throws(() => versioning.rollbackTo(skillDir, 1), error => error.code === 'EEXIST'); + } finally { + fs.linkSync = linkSync; + } + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Unsnapshotted work\n'); + assert.equal(fs.readFileSync(target, 'utf8'), '# Foreign snapshot\n'); + assert.deepEqual(fs.readdirSync(versionsDir).sort(), ['v1.md', 'v2.md']); + assert.equal(versioning.getEvolutionLog(skillDir, 'amendments').filter(row => row.event === 'rollback').length, 0); +}); + +test('snapshot staging cleanup preserves foreign entries and permits a clean later retry', fixture => { + const { skillDir, versionsDir } = fixture; + versioning.createVersion(skillDir); + const live = path.join(skillDir, 'SKILL.md'); + fs.writeFileSync(live, '# Unsnapshotted work\n'); + const linkSync = fs.linkSync; + let foreignPath; + fs.linkSync = (source, destination) => { + if (destination === path.join(versionsDir, 'v2.md')) { + foreignPath = path.join(path.dirname(source), 'foreign-owned.txt'); + fs.writeFileSync(foreignPath, 'foreign work'); + } + return linkSync(source, destination); + }; + try { + assert.throws(() => versioning.rollbackTo(skillDir, 1), error => /recovery is pending/.test(error.message)); + } finally { + fs.linkSync = linkSync; + } + assert.ok(foreignPath, 'foreign entry must be injected into publication staging'); + assert.equal(fs.readFileSync(foreignPath, 'utf8'), 'foreign work'); + assert.equal(fs.readFileSync(live, 'utf8'), '# Unsnapshotted work\n'); + assert.equal(fs.existsSync(path.join(versionsDir, 'v2.md')), false); + assert.equal(versioning.getCurrentVersion(skillDir), 1); + assert.equal(versioning.getEvolutionLog(skillDir, 'amendments').filter(row => row.event === 'rollback').length, 0); + const restored = versioning.rollbackTo(skillDir, 1); + assert.equal(restored.version, 2); + assert.equal(fs.readFileSync(restored.path, 'utf8'), fs.readFileSync(live, 'utf8')); + assert.equal(fs.readFileSync(foreignPath, 'utf8'), 'foreign work'); +}); + +for (const phase of ['storage', 'publication']) { +for (const foreign of [false, true]) { +test(`unverified ${phase} staging directory identity preserves ${foreign ? 'foreign contents' : 'empty directory'} with a pending diagnostic`, fixture => { + const { skillDir, versionsDir } = fixture; + versioning.createVersion(skillDir); + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Unsnapshotted work\n'); + const logPath = versioning.getEvolutionLogPath(skillDir, 'amendments'); + const priorLog = fs.readFileSync(logPath, 'utf8'); + const lstatSync = fs.lstatSync; + let stagingDir; + const primary = Object.assign(new Error('Injected staging identity failure'), { code: 'EIO' }); + fs.lstatSync = (file, ...args) => { + const name = path.basename(file); + if (phase === 'storage' ? name.startsWith('.snapshot-storage-') : name.startsWith('.snapshot-') && !name.startsWith('.snapshot-storage-')) { + stagingDir = file; + if (foreign) fs.writeFileSync(path.join(file, 'foreign-owned.txt'), 'preserve'); + throw primary; + } + return lstatSync(file, ...args); + }; + try { + assert.throws(() => versioning.rollbackTo(skillDir, 1), error => + error.primaryError === primary && /identity could not be verified/.test(error.message) && /recovery is pending/.test(error.message)); + } finally { + fs.lstatSync = lstatSync; + } + if (foreign) assert.equal(fs.readFileSync(path.join(stagingDir, 'foreign-owned.txt'), 'utf8'), 'preserve'); + else assert.deepEqual(fs.readdirSync(stagingDir), []); + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Unsnapshotted work\n'); + assert.equal(fs.existsSync(path.join(versionsDir, 'v2.md')), false); + assert.equal(versioning.getCurrentVersion(skillDir), 1); + assert.equal(fs.readFileSync(logPath, 'utf8'), priorLog); + const restored = versioning.rollbackTo(skillDir, 1); + assert.equal(restored.version, 2); + if (foreign) assert.equal(fs.readFileSync(path.join(stagingDir, 'foreign-owned.txt'), 'utf8'), 'preserve'); + else assert.deepEqual(fs.readdirSync(stagingDir), []); +}); + +} +} + +for (const rollback of [false, true]) { + test(`${rollback ? 'rollback' : 'snapshot'} rejects unsupported hardlink storage before initializing history`, fixture => { + const { skillDir, versionsDir } = fixture; + if (rollback) { + fs.mkdirSync(versionsDir); + fs.writeFileSync(path.join(versionsDir, 'v1.md'), '# Saved target\n'); + } + const linkSync = fs.linkSync; + const primary = Object.assign(new Error('Injected unsupported hard links'), { code: 'EOPNOTSUPP' }); + fs.linkSync = () => { throw primary; }; + try { + assert.throws(() => rollback ? versioning.rollbackTo(skillDir, 1) : versioning.createVersion(skillDir), error => + /requires hardlink-capable storage/.test(error.message) && error.primaryError === primary); + } finally { + fs.linkSync = linkSync; + } + assert.equal(fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8'), '# Original\n'); + assert.equal(fs.existsSync(versioning.getEvolutionDir(skillDir)), false); + if (rollback) { + assert.deepEqual(fs.readdirSync(versionsDir), ['v1.md']); + assert.equal(fs.readFileSync(path.join(versionsDir, 'v1.md'), 'utf8'), '# Saved target\n'); + } else assert.equal(fs.existsSync(versionsDir), false); + assert.equal(fs.readdirSync(skillDir).filter(name => name.startsWith('.snapshot-')).length, 0); + const snapshot = versioning.createVersion(skillDir); + assert.equal(snapshot.version, rollback ? 2 : 1); + }); +} + +test('successful rollback snapshots restored content and retains earlier targets for another rollback', fixture => { + const { skillDir } = fixture; + versioning.createVersion(skillDir); + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Second version\n'); + versioning.createVersion(skillDir); + fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Unsnapshotted work\n'); + const restored = versioning.rollbackTo(skillDir, 1); + assert.equal(restored.version, 3); + assert.equal(fs.readFileSync(restored.path, 'utf8'), '# Original\n'); + assert.equal(fs.readFileSync(restored.path, 'utf8'), fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8')); + const second = versioning.rollbackTo(skillDir, 2); + assert.equal(second.version, 4); + assert.equal(fs.readFileSync(second.path, 'utf8'), '# Second version\n'); + assert.equal(fs.readFileSync(second.path, 'utf8'), fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8')); + assert.equal(versioning.getCurrentVersion(skillDir), 4); +}); + +console.log(`Results: Passed: ${passed}, Failed: ${failed}`); +process.exitCode = failed > 0 ? 1 : 0; diff --git a/tests/lib/skill-evolution.test.js b/tests/lib/skill-evolution.test.js index f2dd4e6ec..1860de247 100644 --- a/tests/lib/skill-evolution.test.js +++ b/tests/lib/skill-evolution.test.js @@ -202,6 +202,53 @@ function runTests() { assert.strictEqual(amendments[1].version, 2); })) passed++; else failed++; + if (test('ignores directories named like version snapshots', () => { + const fixtureRoot = createTempDir('skill-version-directory-'); + try { + const skillDir = createSkill(fixtureRoot, 'demo', '# Demo\n'); + const snapshotDirectory = path.join(versioning.getVersionsDir(skillDir), 'v999.md'); + fs.mkdirSync(snapshotDirectory, { recursive: true }); + fs.writeFileSync(path.join(versioning.getVersionsDir(skillDir), 'notes.txt'), 'Not a snapshot'); + + assert.deepStrictEqual(versioning.listVersions(skillDir), []); + assert.strictEqual(versioning.getCurrentVersion(skillDir), 1); + const snapshot = versioning.createVersion(skillDir); + assert.strictEqual(snapshot.version, 1); + assert.deepStrictEqual(versioning.listVersions(skillDir).map(entry => entry.version), [1]); + assert.deepStrictEqual( + versioning.listVersions(path.join(skillDir, 'SKILL.md')).map(entry => entry.version), + [1] + ); + assert.strictEqual(versioning.getCurrentVersion(skillDir), 1); + assert.ok(fs.statSync(snapshotDirectory).isDirectory()); + for (const version of [2, 3]) { + fs.mkdirSync(path.join(versioning.getVersionsDir(skillDir), `v${version}.md`)); + } + assert.strictEqual(versioning.createVersion(skillDir).version, 4); + assert.deepStrictEqual(versioning.listVersions(skillDir).map(entry => entry.version), [1, 4]); + for (const version of [2, 3]) { + assert.ok(fs.statSync(path.join(versioning.getVersionsDir(skillDir), `v${version}.md`)).isDirectory()); + } + assert.strictEqual(versioning.getCurrentVersion(path.join(fixtureRoot, 'missing-skill')), 0); + assert.throws(() => versioning.createVersion(snapshotDirectory), /Skill file not found/); + const oversizedSnapshot = path.join(versioning.getVersionsDir(skillDir), 'v9007199254740992.md'); + fs.writeFileSync(oversizedSnapshot, 'Preserve this snapshot'); + const overflow = spawnSync(process.execPath, [ + '-e', 'require("assert").strictEqual(require(process.argv[1]).createVersion(process.argv[2]).version, 5)', + require.resolve('../../scripts/lib/skill-evolution/versioning'), skillDir, + ], { encoding: 'utf8', timeout: 10000 }); + assert.strictEqual(overflow.status, 0, overflow.error?.message || overflow.stderr); + assert.strictEqual(fs.readFileSync(oversizedSnapshot, 'utf8'), 'Preserve this snapshot'); + // Unsafe names are excluded from listing, while the actual safe range boundary refuses allocation. + const exhaustedSnapshot = path.join(versioning.getVersionsDir(skillDir), `v${Number.MAX_SAFE_INTEGER}.md`); + fs.writeFileSync(exhaustedSnapshot, 'Preserve the range boundary'); + assert.throws(() => versioning.createVersion(skillDir), /safe integer/); + assert.strictEqual(fs.readFileSync(exhaustedSnapshot, 'utf8'), 'Preserve the range boundary'); + } finally { + cleanupTempDir(fixtureRoot); + } + })) passed++; else failed++; + if (test('rolls back to a previous snapshot without losing history', () => { const skillDir = path.join(skillsRoot, 'alpha'); @@ -294,13 +341,30 @@ function runTests() { duration_ms: 1, user_feedback: 'accepted', recorded_at: '2026-03-15T11:45:00.000Z', - })}\n{bad-json}\n`, + })}\n{bad-json}\nnull\n42\nfalse\n"not a record"\n[]\n{}\n{"skill_id":42}\n{"skill_id":""}\n{"skill_id":"alpha","outcome":"invalid","recorded_at":"2026-03-15T11:45:00.000Z"}\n{"skill_id":"alpha","outcome":"success","recorded_at":"bad-date"}\n`, 'utf8' ); const records = tracker.readSkillExecutionRecords({ runsFilePath: malformedRunsFile }); assert.strictEqual(records.length, 1); assert.strictEqual(records[0].skill_id, 'alpha'); + const report = health.collectSkillHealth({ + repoRoot, homeDir, runsFilePath: malformedRunsFile, now, + }); + assert.strictEqual(report.skills.find(skill => skill.skill_id === 'alpha').run_count_30d, 1); + + const result = runCli([ + '--json', + '--skills-root', skillsRoot, + '--learned-root', learnedRoot, + '--imported-root', importedRoot, + '--home', homeDir, + '--runs-file', malformedRunsFile, + '--now', now, + ]); + assert.strictEqual(result.status, 0, result.stderr); + const payload = JSON.parse(result.stdout); + assert.strictEqual(payload.skills.find(skill => skill.skill_id === 'alpha').run_count_30d, 1); })) passed++; else failed++; if (test('preserves zero-valued telemetry fields during normalization', () => { @@ -580,6 +644,36 @@ function runTests() { ); })) passed++; else failed++; + if (test('zero warning threshold distinguishes unchanged rates from actual trends', () => { + const recent = '2026-03-14T10:00:00.000Z'; + const older = '2026-02-24T10:00:00.000Z'; + const records = [ + { skill_id: 'unchanged', outcome: 'success', recorded_at: recent }, + { skill_id: 'improving', outcome: 'failure', recorded_at: older }, + { skill_id: 'improving', outcome: 'success', recorded_at: recent }, + { skill_id: 'declining', outcome: 'success', recorded_at: older }, + { skill_id: 'declining', outcome: 'failure', recorded_at: recent }, + ]; + const report = health.collectSkillHealth({ + repoRoot, + homeDir, + now, + warnThreshold: 0, + stateStore: { listSkillExecutionRecords: () => records }, + }); + + assert.strictEqual(report.warn_threshold, 0); + for (const [skillId, expectedTrend] of [ + ['unchanged', 'stable'], + ['improving', 'improving'], + ['declining', 'worsening'], + ]) { + const skill = report.skills.find(entry => entry.skill_id === skillId); + assert.strictEqual(skill.failure_trend, expectedTrend); + assert.strictEqual(skill.declining, expectedTrend === 'worsening'); + } + })) passed++; else failed++; + if (test('does not report unmeasured skills as healthy (#2463)', () => { // A runs file that does not exist: skills are still discovered, so this // is exactly the "discovered but never executed" state. diff --git a/tests/lib/statusline-render.test.js b/tests/lib/statusline-render.test.js index a46fd96f4..b85843f07 100644 --- a/tests/lib/statusline-render.test.js +++ b/tests/lib/statusline-render.test.js @@ -280,7 +280,7 @@ function runTests() { assert.strictEqual(summary.disabledCount, 2); }); - console.log(`\nResults: ${passed} passed, ${failed} failed\n`); + console.log(`\nResults: Passed: ${passed}, Failed: ${failed}\n`); return { passed, failed }; } diff --git a/tests/scripts/plan-canvas.test.js b/tests/scripts/plan-canvas.test.js index 1ee9036a2..c214ee150 100644 --- a/tests/scripts/plan-canvas.test.js +++ b/tests/scripts/plan-canvas.test.js @@ -1267,20 +1267,33 @@ async function main(suite = createTestRunner()) { const bound = await staleCanvas.listen(0); const opened = jsonBody(await request(bound.port, 'POST', '/api/sessions', { body: { file: staleArtifact } })); - await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'typing' } }); - assert.strictEqual(staleCanvas.presenceFor(opened.key), 'typing'); - await new Promise(resolve => setTimeout(resolve, 60)); - assert.strictEqual(staleCanvas.presenceFor(opened.key), 'waiting'); + // Keep real HTTP transitions, but advance their activity clock explicitly: + // loaded runners can exceed the expiry between two HTTP round trips. + const originalNow = Date.now; + let now = originalNow(); + Date.now = () => now; + try { + await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'typing' } }); + assert.strictEqual(staleCanvas.presenceFor(opened.key), 'typing'); + now += 19; + assert.strictEqual(staleCanvas.presenceFor(opened.key), 'typing'); + now += 1; + assert.strictEqual(staleCanvas.presenceFor(opened.key), 'waiting'); - // An abandoned agent decays to queued so the human is never told a - // stalled session is still being worked on. - await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'thinking' } }); - await request(bound.port, 'POST', `/api/session/${opened.key}/feedback`, { - body: { items: [{ kind: 'chat', text: 'still there?' }] } - }); - assert.strictEqual(staleCanvas.presenceFor(opened.key), 'thinking'); - await new Promise(resolve => setTimeout(resolve, 60)); - assert.strictEqual(staleCanvas.presenceFor(opened.key), 'queued'); + // An abandoned agent decays to queued so the human is never told a + // stalled session is still being worked on. + await request(bound.port, 'POST', `/api/session/${opened.key}/typing`, { body: { state: 'thinking' } }); + await request(bound.port, 'POST', `/api/session/${opened.key}/feedback`, { + body: { items: [{ kind: 'chat', text: 'still there?' }] } + }); + assert.strictEqual(staleCanvas.presenceFor(opened.key), 'thinking'); + now += 39; + assert.strictEqual(staleCanvas.presenceFor(opened.key), 'thinking'); + now += 1; + assert.strictEqual(staleCanvas.presenceFor(opened.key), 'queued'); + } finally { + Date.now = originalNow; + } await closeStaleCanvas(); }); diff --git a/tests/test_resolver.py b/tests/test_resolver.py index 24c2d80ae..25e6bfcac 100644 --- a/tests/test_resolver.py +++ b/tests/test_resolver.py @@ -258,6 +258,35 @@ class TestSelectedModel: assert get_provider().get_default_model() == "claude-sonnet-4-6" + @pytest.mark.parametrize("saved_provider", [None, "", " ", '""', "' '"]) + def test_missing_or_blank_saved_provider_ignores_unpaired_model( + self, tmp_path: Path, saved_provider: str | None, + ) -> None: + provider_line = "" if saved_provider is None else f"LLM_PROVIDER={saved_provider}\n" + tmp_path.joinpath(".llm.env").write_text(provider_line + "LLM_MODEL=orphan-model\n") + + provider = get_provider() + + assert provider.provider_type == ProviderType.CLAUDE + assert provider.get_default_model() == "claude-sonnet-4-6" + + @pytest.mark.parametrize("explicit", [False, True]) + def test_blank_saved_provider_preserves_provider_and_model_overrides( + self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path, explicit: bool, + ) -> None: + tmp_path.joinpath(".llm.env").write_text('LLM_PROVIDER=""\nLLM_MODEL=orphan-model\n') + if explicit: + provider = get_provider("ollama", default_model="explicit-model") + expected_model = "explicit-model" + else: + monkeypatch.setenv("LLM_PROVIDER", "ollama") + monkeypatch.setenv("LLM_MODEL", "environment-model") + provider = get_provider() + expected_model = "environment-model" + + assert provider.provider_type == ProviderType.OLLAMA + assert provider.get_default_model() == expected_model + @pytest.mark.parametrize("explicit", [False, True]) def test_provider_override_does_not_read_invalid_saved_file( self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path, explicit: bool,