engineering-memory 1.11.24 → 1.11.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.24",
+  "version": "1.11.25",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/build.json

@@ -1,3 +1,3 @@
 {
-  "gitHead": "8d3dfecc2ad6ed7593bb48fa0dbed384acac1a64"
+  "gitHead": "487a37fd63becd1520c4e1f5e4ba13ed2de828e2"
 }

package/runtime/dist/src/git/git-inspector.js

@@ -10,8 +10,10 @@ export const temporaryScaffoldingMarker = 'ENGINEERING-MEMORY-TEMPORARY';
 export const temporaryScaffoldingPattern = `${temporaryScaffoldingMarker}:`;
 export class GitInspector {
     runner;
-    constructor(runner = new NativeCommandRunner()) {
+    knownReservations;
+    constructor(runner = new NativeCommandRunner(), knownReservations) {
         this.runner = runner;
+        this.knownReservations = knownReservations;
     }
     async findRoot(startPath) {
         const result = await this.runner.run('git', ['rev-parse', '--show-toplevel'], {
@@ -49,7 +51,7 @@ export class GitInspector {
             : null;
     }
     branchStore(repoRoot) {
-        return new TaskBranchStore(repoRoot, this.runner);
+        return new TaskBranchStore(repoRoot, this.runner, this.knownReservations);
     }
     async validateBranch(repoRoot, name) {
         const result = await this.runner.run('git', ['check-ref-format', '--branch', name], {

package/runtime/dist/src/runtime/create-bridge-service.js

@@ -46,9 +46,20 @@ export function createBridgeService(options = {}) {
         liveHeader: (path) => live.header(path),
     });
     const live = new LiveSignals(client);
-    const git = new GitInspector();
-    const outbox = new OfflineOutbox(stateRoot);
     const activeContexts = new ActiveContextStore(stateRoot);
+    const knownReservations = async (repoRoot) => (await activeContexts.list((await repositories.resolveIdentity(repoRoot)).repoFingerprint)).flatMap((pointer) => pointer.branch === undefined
+        ? []
+        : [
+            {
+                projectId: pointer.projectId,
+                externalTaskId: pointer.taskSlug,
+                branch: pointer.branch,
+                taskId: pointer.taskId,
+            },
+        ]);
+    const git = new GitInspector(undefined, knownReservations);
+    const repositories = new RepositoryResolver(git, config.markerSchemaVersion, stateRoot);
+    const outbox = new OfflineOutbox(stateRoot);
     const repositoryDecisions = new RepositoryDecisionStore(stateRoot);
     const updateChoices = new UpdateChoiceStore(stateRoot);
     const shadowNotices = new ShadowNoticeStore(stateRoot);
@@ -64,6 +75,7 @@ export function createBridgeService(options = {}) {
                 (await outbox.listForTask(entry.taskId)).length);
         },
         onDeliveryOutcome: async (report) => service?.reportDeliveryOutcome(report),
+        knownReservations,
     });
     const gate = new VerificationGate(stateRoot, git, outbox, undefined, worktreePool);
     const principalState = new PrincipalStateGuard(stateRoot, credentials, cache, outbox, activeContexts, gate);
@@ -76,7 +88,7 @@ export function createBridgeService(options = {}) {
         client,
         credentials,
         browserAuth: new BrowserAuthCoordinator(client, credentials, () => languages.read(sha256('anonymous'))),
-        repositories: new RepositoryResolver(git, config.markerSchemaVersion, stateRoot),
+        repositories,
         journal: new JournalStore(stateRoot),
         outbox,
         gate,

package/runtime/dist/src/runtime/task-branch-store.js

@@ -1,13 +1,18 @@
+import { createHash } from 'node:crypto';
 import { NativeCommandRunner } from '../utilities/process.js';
 import { assertSafeToPersist } from './offline-outbox.js';
 import { BridgeRecoveryError } from './recovery-error.js';
 const decisionRef = 'refs/worktree/engineering-memory-task';
+const keptRef = (oid) => 'refs/engineering-memory/task-reservations/' + oid;
+const kept = new Set();
 export class TaskBranchStore {
     repoRoot;
     runner;
-    constructor(repoRoot, runner = new NativeCommandRunner()) {
+    known;
+    constructor(repoRoot, runner = new NativeCommandRunner(), known) {
         this.repoRoot = repoRoot;
         this.runner = runner;
+        this.known = known;
     }
     async read() {
         const reference = await this.runner.run('git', ['rev-parse', '--verify', '--quiet', decisionRef], { cwd: this.repoRoot });
@@ -17,8 +22,12 @@ export class TaskBranchStore {
             throw new BridgeRecoveryError('Git could not read the worktree task reservation. Retry the branch operation.', 'task.branch');
         const oid = reference.stdout.trim();
         const blob = await this.runner.run('git', ['cat-file', 'blob', oid], { cwd: this.repoRoot });
-        if (blob.exitCode !== 0)
-            throw new BridgeRecoveryError('Git could not read the recorded branch decision. Retry the branch operation.', 'task.branch');
+        if (blob.exitCode !== 0) {
+            const found = await this.runner.run('git', ['cat-file', '-e', oid], { cwd: this.repoRoot });
+            if (found.exitCode !== 1 || !this.known)
+                throw new BridgeRecoveryError('Git could not read the recorded branch decision. Retry the branch operation.', 'task.branch');
+            return await this.restore(oid, await this.known(this.repoRoot));
+        }
         let decision;
         try {
             decision = JSON.parse(blob.stdout);
@@ -33,6 +42,7 @@ export class TaskBranchStore {
             !(decision.branch === null || typeof decision.branch === 'string')) {
             throw new BridgeRecoveryError('The worktree branch record is invalid. Use a separate worktree to continue this task.', 'task.branch');
         }
+        await this.keep(oid);
         return { oid, decision };
     }
     async reserve(decision) {
@@ -43,7 +53,10 @@ export class TaskBranchStore {
             return;
         }
         const oid = await this.hash(decision);
-        const written = await this.runner.run('git', ['update-ref', '--no-deref', decisionRef, oid, '0'.repeat(oid.length)], { cwd: this.repoRoot });
+        const written = await this.update([
+            `create ${decisionRef} ${oid}`,
+            `update ${keptRef(oid)} ${oid}`,
+        ]);
         if (written.exitCode !== 0) {
             const winner = await this.read();
             if (winner) {
@@ -62,7 +75,11 @@ export class TaskBranchStore {
         if (current.decision.taskId === taskId)
             return;
         const oid = await this.hash({ ...current.decision, taskId });
-        const result = await this.runner.run('git', ['update-ref', '--no-deref', decisionRef, oid, current.oid], { cwd: this.repoRoot });
+        const result = await this.update([
+            `update ${decisionRef} ${oid} ${current.oid}`,
+            `update ${keptRef(oid)} ${oid}`,
+            `delete ${keptRef(current.oid)}`,
+        ]);
         if (result.exitCode !== 0) {
             const latest = await this.read();
             if (latest?.decision.taskId !== taskId)
@@ -76,7 +93,7 @@ export class TaskBranchStore {
             current.decision.projectId !== projectId ||
             current.decision.externalTaskId !== externalTaskId)
             return;
-        const result = await this.runner.run('git', ['update-ref', '--no-deref', '-d', decisionRef, current.oid], { cwd: this.repoRoot });
+        const result = await this.remove(current.oid);
         if (result.exitCode !== 0 && (await this.read())?.oid === current.oid)
             throw new BridgeRecoveryError('The failed branch operation could not release its reservation. Retry task.branch with the same task identifier.', 'task.branch');
     }
@@ -84,7 +101,7 @@ export class TaskBranchStore {
         const current = await this.read();
         if (!current || current.decision.taskId !== taskId)
             return;
-        const result = await this.runner.run('git', ['update-ref', '--no-deref', '-d', decisionRef, current.oid], { cwd: this.repoRoot });
+        const result = await this.remove(current.oid);
         if (result.exitCode !== 0 && (await this.read())?.decision.taskId === taskId) {
             throw new BridgeRecoveryError('The task has finished but its worktree reservation could not be released. Resume the task to retry cleanup.', 'session.resume');
         }
@@ -98,7 +115,7 @@ export class TaskBranchStore {
             current.decision.externalTaskId !== expected.externalTaskId ||
             current.decision.taskId !== expected.taskId)
             throw changed();
-        const result = await this.runner.run('git', ['update-ref', '--no-deref', '-d', decisionRef, oid], { cwd: this.repoRoot });
+        const result = await this.remove(oid);
         if (result.exitCode !== 0) {
             if ((await this.read())?.oid !== oid)
                 throw changed();
@@ -114,6 +131,48 @@ export class TaskBranchStore {
             throw new BridgeRecoveryError(`This task selected ${current.branch ?? 'detached HEAD'}. Return to that branch before continuing.`, 'task.branch');
         }
     }
+    async restore(oid, known) {
+        for (const task of known) {
+            const unopened = {
+                projectId: task.projectId,
+                externalTaskId: task.externalTaskId,
+                branch: task.branch,
+            };
+            for (const decision of [{ ...unopened, taskId: task.taskId }, unopened]) {
+                const body = Buffer.from(JSON.stringify(decision));
+                const id = createHash(oid.length === 64 ? 'sha256' : 'sha1')
+                    .update(`blob ${body.length}\0`)
+                    .update(body)
+                    .digest('hex');
+                if (id !== oid)
+                    continue;
+                await this.hash(decision);
+                await this.keep(oid);
+                return { oid, decision };
+            }
+        }
+        if ((await this.remove(oid)).exitCode !== 0)
+            throw new BridgeRecoveryError('Git could not read the recorded branch decision. Retry the branch operation.', 'task.branch');
+        return null;
+    }
+    async keep(oid) {
+        if (kept.has(this.repoRoot + '\n' + oid))
+            return;
+        const result = await this.runner.run('git', ['update-ref', keptRef(oid), oid], {
+            cwd: this.repoRoot,
+        });
+        if (result.exitCode === 0)
+            kept.add(this.repoRoot + '\n' + oid);
+    }
+    async remove(oid) {
+        return await this.update([`delete ${decisionRef} ${oid}`, `delete ${keptRef(oid)}`]);
+    }
+    async update(commands) {
+        return await this.runner.run('git', ['update-ref', '--no-deref', '--stdin'], {
+            cwd: this.repoRoot,
+            input: commands.join('\n') + '\n',
+        });
+    }
     async hash(decision) {
         const result = await this.runner.run('git', ['hash-object', '-w', '--stdin'], {
             cwd: this.repoRoot,

package/runtime/dist/src/runtime/worktree-pool.js

@@ -131,7 +131,7 @@ export class WorktreePool {
         this.stateRoot = stateRoot;
         this.ownerId = options.ownerId ?? randomUUID();
         this.runner = options.runner ?? new NativeCommandRunner();
-        this.git = new GitInspector(this.runner);
+        this.git = new GitInspector(this.runner, options.knownReservations);
         this.now = options.now ?? Date.now;
         this.alive = options.processAlive ?? processAlive;
         this.documents = options.documentsRoot;