Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

fix(session): preserve alias identity when its store is unreadable

haelyraf614e82ae58a
diff --git a/scripts/lib/session-adapters/claude-history.js b/scripts/lib/session-adapters/claude-history.js
index 8f5f07271..a42c46283 100644
--- a/scripts/lib/session-adapters/claude-history.js
+++ b/scripts/lib/session-adapters/claude-history.js
@@ -73,15 +73,7 @@ function resolveSessionRecord(target, cwd) {
};
}
- let alias;
- let aliasReadError;
- try {
- alias = sessionAliases.resolveAlias(explicitTarget);
- } catch (error) {
- // Alias lookup is optional when the supplied identifier independently
- // resolves to recorded history. Preserve the error otherwise.
- aliasReadError = error;
- }
+ const alias = sessionAliases.resolveAlias(explicitTarget);
if (alias) {
return {
session: hydrateSessionFromPath(alias.sessionPath),
@@ -94,7 +86,6 @@ function resolveSessionRecord(target, cwd) {
const session = sessionManager.getSessionById(explicitTarget, true);
if (!session) {
- if (aliasReadError) throw aliasReadError;
throw new Error(`Claude session not found: ${explicitTarget}`);
}
diff --git a/tests/lib/claude-history-alias-unavailable.test.js b/tests/lib/claude-history-alias-unavailable.test.js
index ec92e3bc0..586b9527c 100644
--- a/tests/lib/claude-history-alias-unavailable.test.js
+++ b/tests/lib/claude-history-alias-unavailable.test.js
@@ -11,51 +11,82 @@ const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-history-
const data = path.join(root, '.claude');
const sessions = path.join(data, 'session-data');
fs.mkdirSync(sessions, { recursive: true });
-const id = '550e8400-e29b-41d4-a716-446655440000';
+const id = 'a1111111-e29b-41d4-a716-446655440000';
+const prefix = id.slice(0, 8);
const name = `2026-10-10-${id}-session.tmp`;
-const sessionFile = path.join(sessions, name);
-fs.writeFileSync(sessionFile, '# History fixture\n**Worktree:** /fixture/project\n\n### Completed\n- [x] existing-history-sentinel\n');
+const sessionA = path.join(sessions, name);
+const sessionB = path.join(sessions, '2026-10-10-b2222222-session.tmp');
+for (const [file, label] of [[sessionA, 'A'], [sessionB, 'B']]) {
+ fs.writeFileSync(file, `# History ${label}\n**Worktree:** /fixture/project\n\n### Completed\n- [x] history-${label}-sentinel\n`);
+}
const aliasPath = path.join(data, 'session-aliases.json');
-const aliasBytes = JSON.stringify({ version: '1.0', aliases: { kept: { sessionPath: sessionFile } } });
+const collisionNames = ['a', prefix, id, 'kept'];
+const aliasBytes = JSON.stringify({ version: '1.0', aliases: Object.fromEntries(
+ collisionNames.map(alias => [alias, { sessionPath: sessionB }])) });
fs.writeFileSync(aliasPath, aliasBytes);
const keys = ['HOME', 'USERPROFILE', 'ECC_AGENT_DATA_HOME'];
const saved = Object.fromEntries(keys.map(key => [key, process.env[key]]));
Object.assign(process.env, { HOME: root, USERPROFILE: root, ECC_AGENT_DATA_HOME: data });
-const adapter = createClaudeHistoryAdapter({ persistSnapshots: false });
+const recording = path.join(root, 'canonical-snapshot.json');
+const publications = [];
+const adapter = createClaudeHistoryAdapter({ persistCanonicalSnapshotImpl(snapshot) {
+ publications.push(snapshot);
+ fs.writeFileSync(recording, JSON.stringify(snapshot));
+} });
let passed = 0;
let failed = 0;
function test(name, run) {
try { run(); passed++; console.log(`PASS ${name}`); }
catch (error) { failed++; console.error(`FAIL ${name}: ${error.stack}`); }
}
+function denyAliasReads(code, run) {
+ const originalRead = fs.readFileSync;
+ const expected = Object.assign(new Error('injected unreadable alias store'), { code });
+ fs.readFileSync = function (file) {
+ if (file === aliasPath) throw expected;
+ return originalRead.apply(this, arguments);
+ };
+ try { run(expected); }
+ finally { fs.readFileSync = originalRead; }
+ assert.strictEqual(fs.readFileSync(aliasPath, 'utf8'), aliasBytes);
+ assert.deepStrictEqual(fs.readdirSync(data).sort(), ['session-aliases.json', 'session-data']);
+}
try {
- test('readable alias retains truthful claude-alias source identity', () => {
- const snapshot = adapter.open('claude:kept').getSnapshot();
- assert.deepStrictEqual(snapshot.session.sourceTarget, { type: 'claude-alias', value: 'kept' });
- assert.strictEqual(snapshot.workers[0].artifacts.sessionFile, sessionFile);
+ test('readable aliases select B despite conflicting A prefixes and UUIDs', () => {
+ for (const alias of collisionNames) {
+ const snapshot = adapter.open(`claude:${alias}`).getSnapshot();
+ assert.deepStrictEqual(snapshot.session.sourceTarget, { type: 'claude-alias', value: alias });
+ assert.strictEqual(snapshot.workers[0].artifacts.sessionFile, sessionB);
+ assert.strictEqual(JSON.parse(fs.readFileSync(recording, 'utf8')).workers[0].artifacts.sessionFile, sessionB);
+ }
assert.strictEqual(fs.readFileSync(aliasPath, 'utf8'), aliasBytes);
});
for (const code of ['EACCES', 'EPERM']) {
- test(`known history remains readable while aliases return ${code}, and unresolved targets still fail`, () => {
- const originalRead = fs.readFileSync;
- const expected = Object.assign(new Error('injected unreadable alias store'), { code });
- fs.readFileSync = function (file) {
- if (file === aliasPath) throw expected;
- return originalRead.apply(this, arguments);
- };
- try {
- for (const target of [id, name]) {
- const snapshot = adapter.open(`claude:${target}`).getSnapshot();
- assert.deepStrictEqual(snapshot.session.sourceTarget, { type: 'claude-history', value: target });
- assert.strictEqual(snapshot.workers[0].artifacts.sessionFile, sessionFile);
- assert.ok(snapshot.workers[0].outputs.summary.includes('existing-history-sentinel'));
+ test(`${code} alias collisions preserve errors and never publish another conversation`, () => {
+ adapter.open('claude:a').getSnapshot();
+ const before = fs.readFileSync(recording, 'utf8');
+ publications.length = 0;
+ denyAliasReads(code, expected => {
+ for (const target of [...collisionNames, 'does-not-exist']) {
+ let thrown;
+ try { adapter.open(`claude:${target}`).getSnapshot(); } catch (error) { thrown = error; }
+ assert.strictEqual(publications.length, 0, 'Unresolved alias identity must not publish any snapshot');
+ assert.strictEqual(fs.readFileSync(recording, 'utf8'), before);
+ assert.strictEqual(thrown, expected);
}
- assert.throws(() => adapter.open('claude:does-not-exist').getSnapshot(), error => error === expected);
- assert.throws(() => adapter.open('claude:kept').getSnapshot(), error => error === expected);
assert.throws(() => aliases.setAlias('added', '/new'), error => error === expected);
- } finally { fs.readFileSync = originalRead; }
- assert.strictEqual(fs.readFileSync(aliasPath, 'utf8'), aliasBytes);
- assert.deepStrictEqual(fs.readdirSync(data).sort(), ['session-aliases.json', 'session-data']);
+ });
+ });
+ test(`${code} still permits an exact filename with truthful history identity`, () => {
+ publications.length = 0;
+ denyAliasReads(code, () => {
+ const snapshot = adapter.open(`claude:${name}`).getSnapshot();
+ assert.deepStrictEqual(snapshot.session.sourceTarget, { type: 'claude-history', value: name });
+ assert.strictEqual(snapshot.workers[0].artifacts.sessionFile, sessionA);
+ assert.ok(snapshot.workers[0].outputs.summary.includes('history-A-sentinel'));
+ assert.strictEqual(publications.length, 1);
+ assert.strictEqual(JSON.parse(fs.readFileSync(recording, 'utf8')).workers[0].artifacts.sessionFile, sessionA);
+ });
});
}
} finally {