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 optional startup context and independent history reads

haelyra0a181df21832
diff --git a/scripts/hooks/session-start.js b/scripts/hooks/session-start.js
index 528b6fcd8..486c52963 100644
--- a/scripts/hooks/session-start.js
+++ b/scripts/hooks/session-start.js
@@ -763,13 +763,17 @@ async function main() {
}
}
- // Check for available session aliases
- const aliases = listAliases({ limit: 5 });
-
- if (aliases.length > 0) {
- const aliasNames = aliases.map(a => a.name).join(', ');
- log(`[SessionStart] ${aliases.length} session alias(es) available: ${aliasNames}`);
- log(`[SessionStart] Use /sessions load <alias> to continue a previous session`);
+ // Alias suggestions are optional. An unreadable store must not discard
+ // already-collected context or prevent the remaining startup guidance.
+ try {
+ const aliases = listAliases({ limit: 5 });
+ if (aliases.length > 0) {
+ const aliasNames = aliases.map(a => a.name).join(', ');
+ log(`[SessionStart] ${aliases.length} session alias(es) available: ${aliasNames}`);
+ log(`[SessionStart] Use /sessions load <alias> to continue a previous session`);
+ }
+ } catch (error) {
+ log(`[SessionStart] Session aliases unavailable: ${error.message}`);
}
// Detect and report package manager
diff --git a/scripts/lib/session-adapters/claude-history.js b/scripts/lib/session-adapters/claude-history.js
index a42c46283..8f5f07271 100644
--- a/scripts/lib/session-adapters/claude-history.js
+++ b/scripts/lib/session-adapters/claude-history.js
@@ -73,7 +73,15 @@ function resolveSessionRecord(target, cwd) {
};
}
- const alias = sessionAliases.resolveAlias(explicitTarget);
+ 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;
+ }
if (alias) {
return {
session: hydrateSessionFromPath(alias.sessionPath),
@@ -86,6 +94,7 @@ 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/hooks/session-start-alias-unavailable.test.js b/tests/hooks/session-start-alias-unavailable.test.js
new file mode 100644
index 000000000..b088d6227
--- /dev/null
+++ b/tests/hooks/session-start-alias-unavailable.test.js
@@ -0,0 +1,74 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const repo = path.resolve(__dirname, '../..');
+const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-startup-alias-read-')));
+const project = path.join(root, 'project');
+const home = path.join(root, 'home');
+const data = path.join(home, '.claude');
+const sessions = path.join(data, 'session-data');
+const learned = path.join(data, 'skills/learned');
+for (const directory of [project, sessions, learned]) fs.mkdirSync(directory, { recursive: true });
+fs.writeFileSync(path.join(project, 'package.json'), '{"name":"startup-fixture","dependencies":{"react":"1.0.0"}}');
+const summary = path.join(sessions, `${new Date().toISOString().slice(0, 10)}-startup-session.tmp`);
+fs.writeFileSync(summary, `# Prior session\n**Worktree:** ${project}\n\nstartup-history-sentinel\n`);
+fs.writeFileSync(path.join(learned, 'startup-skill.md'), '# Startup skill\n\n## When to Use\nstartup-learned-sentinel\n');
+const aliasPath = path.join(data, 'session-aliases.json');
+const aliasBytes = JSON.stringify({ version: '1.0', aliases: { kept: { sessionPath: summary, createdAt: new Date().toISOString() } } });
+fs.writeFileSync(aliasPath, aliasBytes);
+const env = { ...process.env, HOME: home, USERPROFILE: home, ECC_AGENT_DATA_HOME: data,
+ CLAUDE_CONFIG_DIR: data, CLAUDE_PROJECT_DIR: project, CLAUDE_PACKAGE_MANAGER: '',
+ XDG_DATA_HOME: path.join(home, '.local/share'), ECC_HOMUNCULUS_DIR: path.join(data, 'homunculus'),
+ ECC_SESSION_START_CONTEXT: 'true', ECC_SESSION_START_MAX_CHARS: '8000', ECC_SESSION_RETENTION_DAYS: '30' };
+let passed = 0;
+let failed = 0;
+try {
+ for (const code of [null, 'EACCES', 'EPERM']) {
+ const faultCount = path.join(root, `fault-count-${code}.json`);
+ const args = [];
+ if (code) {
+ const preload = path.join(root, `deny-${code}.cjs`);
+ fs.writeFileSync(preload, [
+ "const fs=require('fs'), vm=require('vm');",
+ `const file=${JSON.stringify(aliasPath)}, helper=${JSON.stringify(path.join(repo, 'scripts/lib/atomic-write.js'))};`,
+ 'const original=fs.readFileSync; let denied=0;',
+ `fs.readFileSync=function(input){ if(input===file){ denied++; throw Object.assign(new Error('injected unreadable aliases'),{code:${JSON.stringify(code)}}); } return original.apply(this,arguments); };`,
+ 'const record={exports:{}};',
+ "vm.runInNewContext(original(helper,'utf8'),{module:record,exports:record.exports,require,process:{platform:'win32',pid:process.pid},performance,Atomics,SharedArrayBuffer,Int32Array},{filename:helper});",
+ 'require.cache[helper]={id:helper,filename:helper,loaded:true,exports:record.exports};',
+ `process.on('exit',()=>fs.writeFileSync(${JSON.stringify(faultCount)},JSON.stringify(denied)));`
+ ].join('\n'));
+ args.push('--require', preload);
+ }
+ try {
+ const result = spawnSync(process.execPath, [...args, path.join(repo, 'scripts/hooks/session-start.js')], {
+ cwd: project, env, input: JSON.stringify({ hook_event_name: 'SessionStart', source: 'startup', session_id: `startup-${code}`, cwd: project }),
+ encoding: 'utf8', timeout: 15000,
+ });
+ assert.ifError(result.error);
+ assert.strictEqual(result.status, 0, result.stderr);
+ const output = JSON.parse(result.stdout);
+ assert.strictEqual(output.hookSpecificOutput.hookEventName, 'SessionStart');
+ const context = output.hookSpecificOutput.additionalContext;
+ assert.match(context, /startup-history-sentinel/);
+ assert.match(context, /HISTORICAL REFERENCE ONLY/);
+ assert.match(context, /startup-learned-sentinel/);
+ assert.match(context, /Project type:/);
+ assert.match(result.stderr, /Package manager:/);
+ assert.match(result.stderr, /No package manager preference found/);
+ if (code) {
+ assert.match(result.stderr, /Session aliases unavailable/);
+ assert.ok(JSON.parse(fs.readFileSync(faultCount, 'utf8')) >= 1);
+ } else assert.match(result.stderr, /session alias\(es\) available: kept/);
+ assert.strictEqual(fs.readFileSync(aliasPath, 'utf8'), aliasBytes);
+ passed++; console.log(`PASS actual startup preserves context with ${code || 'readable'} aliases`);
+ } catch (error) { failed++; console.error(`FAIL ${code || 'readable'}: ${error.stack}`); }
+ }
+} finally { fs.rmSync(root, { recursive: true, force: true }); }
+console.log(`Results: Passed: ${passed}, Failed: ${failed}`);
+process.exitCode = failed ? 1 : 0;
diff --git a/tests/lib/claude-history-alias-unavailable.test.js b/tests/lib/claude-history-alias-unavailable.test.js
new file mode 100644
index 000000000..ec92e3bc0
--- /dev/null
+++ b/tests/lib/claude-history-alias-unavailable.test.js
@@ -0,0 +1,68 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { createClaudeHistoryAdapter } = require('../../scripts/lib/session-adapters/claude-history');
+const aliases = require('../../scripts/lib/session-aliases');
+
+const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-history-alias-read-')));
+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 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 aliasPath = path.join(data, 'session-aliases.json');
+const aliasBytes = JSON.stringify({ version: '1.0', aliases: { kept: { sessionPath: sessionFile } } });
+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 });
+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}`); }
+}
+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);
+ 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'));
+ }
+ 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']);
+ });
+ }
+} finally {
+ for (const [key, value] of Object.entries(saved)) {
+ if (value === undefined) delete process.env[key]; else process.env[key] = value;
+ }
+ fs.rmSync(root, { recursive: true, force: true });
+}
+console.log(`Results: Passed: ${passed}, Failed: ${failed}`);
+process.exitCode = failed ? 1 : 0;