engineering-memory 1.11.12 → 1.11.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.12",
+  "version": "1.11.14",
   "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",
@@ -11,7 +11,7 @@
     "engineering-memory": "bin/engineering-memory.mjs"
   },
   "files": [
-    "bin",
+    "bin/engineering-memory.mjs",
     "dispatcher",
     "lib",
     "install",

package/runtime/build.json

@@ -1,3 +1,3 @@
 {
-  "gitHead": "de721a5d678590e09a9f1085f8f3b976a1791b35"
+  "gitHead": "df9e70a543ee3b3f57a102e251df657ef6a62618"
 }

package/runtime/dist/src/mcp/onboarding-tools.js

@@ -2,7 +2,7 @@ import * as z from 'zod/v4';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { restrictedValueKind } from '../runtime/privacy-detector.js';
 import { languageTag } from '../runtime/questionnaire-store.js';
-import { answerChoice, answerData, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
+import { answerChoice, answerData, askFailed, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
 const uuid = z.string().uuid();
 const hash = z.string().regex(/^[a-f0-9]{64}$/);
 const project = { projectId: uuid };
@@ -411,18 +411,30 @@ export function registerOnboardingTools(server, service) {
                 ],
             };
         });
-        const form = await askQuestionnaire(server, service, {
-            ...definitions.find((entry) => entry.language === language),
+        const binding = { decision: questionnaireId };
+        const bound = definitions.map((entry) => ({ ...entry, binding }));
+        const asked = {
             repoRoot: input.repoRoot,
+            questionnaireId,
             presentation: input.presentation,
-        }, context, [...definitions, ...previousWording], {
-            tool: 'project.move_repository',
-            ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
-            retryArguments: {
-                projectId: input.projectId,
-                ...(input.language ? { language: input.language } : {}),
-            },
-        });
+        };
+        const stored = await service.questionnaireResume(asked).catch(() => undefined);
+        const form = stored?.binding && stableStringify(stored.binding) === stableStringify(binding)
+            ? await resumeQuestionnaire(server, service, asked, context)
+            : await askQuestionnaire(server, service, {
+                ...bound.find((entry) => entry.language === language),
+                repoRoot: input.repoRoot,
+                presentation: input.presentation,
+            }, context, [...bound, ...definitions, ...previousWording], {
+                tool: 'project.move_repository',
+                ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+                retryArguments: {
+                    projectId: input.projectId,
+                    ...(input.language ? { language: input.language } : {}),
+                },
+            });
+        if (askFailed(form))
+            return form;
         const record = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId,

package/runtime/dist/src/mcp/questionnaire-tools.js

@@ -8,18 +8,29 @@ export async function askQuestionnaire(server, service, input, context, previous
         return failure(error);
     }
 }
+export function askFailed(result) {
+    return payload(result)?.ok === false;
+}
 export function answerChoice(result) {
     return answerData(result)?.choice;
 }
 export function answerData(result) {
+    const value = payload(result);
+    return value?.ok && value.data?.status === 'answered' && value.data.answerAvailable
+        ? value.data.answer
+        : undefined;
+}
+function payload(result) {
     const response = result;
     const text = response.content?.find((item) => item.type === 'text')?.text;
     if (!text)
         return undefined;
-    const value = JSON.parse(text);
-    return value.ok && value.data?.status === 'answered' && value.data.answerAvailable
-        ? value.data.answer
-        : undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
 }
 export async function resumeQuestionnaire(server, service, input, context) {
     try {

package/runtime/dist/src/mcp/tool-definitions.js

@@ -2,7 +2,7 @@ import * as z from 'zod/v4';
 import { validationIds } from '../runtime/bridge-service.js';
 import { stableStringify } from '../utilities/hash.js';
 import { hostAnswerSchema, languageTag, questionnaireDefinitionSchema, } from '../runtime/questionnaire-store.js';
-import { answerChoice, answerQuestionnaireFromHost, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
+import { answerChoice, answerQuestionnaireFromHost, askFailed, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
 const optionalRepoRoot = z.string().min(1).optional();
 const stringList = z.array(z.string().min(1));
 const jsonValue = z.lazy(() => z.union([
@@ -726,6 +726,8 @@ export function registerEngineeringMemoryTools(server, service) {
                 ...definitions.find((definition) => definition.language === language),
                 repoRoot: request.repoRoot,
             }, context, [...definitions, ...earlier]);
+            if (askFailed(form))
+                return form;
             const record = await service.questionnaireResume({
                 repoRoot: request.repoRoot,
                 questionnaireId,
@@ -930,15 +932,13 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.workItemCreate(input)));
     server.registerTool('work_item.update', {
-        description: 'Edit or assign a work item at its current version. Assignees must already be active project members; this does not grant project access.',
+        description: "Edit or assign a work item at its current version. Assignees must already be active project members; this does not grant project access. Status is a slug from the project's own status catalogue; a backend that still keeps the six legacy values (backlog, ready, in_progress, in_review, done, cancelled) refuses anything else and names what it accepts.",
         inputSchema: z.object({
             ...workItemLocator,
             data: z.object({
                 ...workItemFields,
                 expectedVersion: z.number().int().min(1),
-                status: z
-                    .enum(['backlog', 'ready', 'in_progress', 'in_review', 'done', 'cancelled'])
-                    .optional(),
+                status: z.string().trim().min(1).max(64).optional(),
             }),
         }),
     }, async (input) => toolResult(await service.workItemUpdate(input)));
@@ -1016,12 +1016,10 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.projectUpdate(input)));
     server.registerTool('work_item.list', {
-        description: 'List selectable work items for a project before opening an engineering run in this chat.',
+        description: "List selectable work items for a project before opening an engineering run in this chat. The status filter is a slug from the project's own status catalogue; a backend that still keeps the six legacy values (backlog, ready, in_progress, in_review, done, cancelled) refuses anything else and names what it accepts.",
         inputSchema: z.object({
             projectId: z.string().uuid(),
-            status: z
-                .enum(['backlog', 'ready', 'in_progress', 'in_review', 'done', 'cancelled'])
-                .optional(),
+            status: z.string().trim().min(1).max(64).optional(),
             priority: z.enum(['lowest', 'low', 'medium', 'high', 'highest']).optional(),
             assigneeUserId: z.string().uuid().optional(),
             includeArchived: z.boolean().optional(),

package/runtime/dist/src/mcp/worktree-tools.js

@@ -1,10 +1,10 @@
 import { basename } from 'node:path';
 import * as z from 'zod/v4';
-import { cancelledDeliveryQuestionId, forgetUnreadableQuestionId, } from '../runtime/bridge-service.js';
+import { cancelledDeliveryQuestionId, forgetUnreadableQuestionId, retireQuestionId, } from '../runtime/bridge-service.js';
 import { configuredBase, sourceLabel, taskStartChoice, taskStartDefinition, } from '../runtime/task-start.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { unreadableWorktree } from '../runtime/worktree-pool.js';
-import { askQuestionnaire } from './questionnaire-tools.js';
+import { askFailed, askQuestionnaire } from './questionnaire-tools.js';
 import { languageTag } from '../runtime/questionnaire-store.js';
 const repo = z.string().min(1);
 const branch = z.string().min(1).max(255);
@@ -333,6 +333,8 @@ export function registerWorktreeTools(server, service) {
             repoRoot: input.repoRoot,
             presentation: input.presentation,
         }, context, [definition(language !== 'tr'), previous(true), previous(false)], owner);
+        if (askFailed(form))
+            return form;
         const record = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId,
@@ -400,11 +402,15 @@ export function registerWorktreeTools(server, service) {
             }),
         };
         const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, [previous], owner);
-        const record = await service.questionnaireResume({
+        const record = await service
+            .questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId: definition.questionnaireId,
-        });
-        const choice = taskStartChoice(record);
+        })
+            .catch(() => undefined);
+        const choice = record?.binding && stableStringify(record.binding) === stableStringify(definition.binding)
+            ? taskStartChoice(record)
+            : null;
         if (!choice)
             return form;
         if (choice.status === 'deferred')
@@ -490,6 +496,8 @@ export function registerWorktreeTools(server, service) {
                 repoRoot: input.repoRoot,
                 presentation: input.presentation,
             }, context, [definition(language !== 'tr'), previousFallback(true), previousFallback(false)], owner);
+            if (askFailed(fallbackForm))
+                return fallbackForm;
             const answer = await service.questionnaireResume({
                 repoRoot: input.repoRoot,
                 questionnaireId: fallbackId,
@@ -531,7 +539,7 @@ export function registerWorktreeTools(server, service) {
         inputSchema: locationSchema,
     }, async (input) => output(await service.worktreeOperation('list', input)));
     server.registerTool('worktree.reconcile', {
-        description: 'Reconcile Git with the local registry, including unregistered legacy checkouts. Use releaseUnowned only on a selected unreserved recovered checkout after prior work has finished; a native source-bound confirmation and fresh safety checks precede reuse. Use retireLegacy only when the user wants old-location slots gone: each retired folder is removed with git worktree remove after its own native approval, and the branch stays. Use forgetUnreadable with the externalTaskId of a checkout that is gone or can no longer be read as a Git worktree, called from a working checkout of the same project: after its own native approval Engineering Memory stops tracking that entry, so it no longer counts toward the limit, and no file in the folder is read, moved or deleted. Otherwise never delete files or reset branches.',
+        description: 'Reconcile Git with the local registry, including unregistered legacy checkouts. Use releaseUnowned only on a selected unreserved recovered checkout after prior work has finished; a native source-bound confirmation and fresh safety checks precede reuse. Use retireLegacy only when the user wants old-location slots gone: each retired folder is removed with git worktree remove after its own native approval, once every retired folder has an answer, and the branch stays. Reconsider a retired folder with a new decisionAttempt; retries keep the same attempt. Use forgetUnreadable with the externalTaskId of a checkout that is gone or can no longer be read as a Git worktree, called from a working checkout of the same project: after its own native approval Engineering Memory stops tracking that entry, so it no longer counts toward the limit, and no file in the folder is read, moved or deleted. Otherwise never delete files or reset branches.',
         inputSchema: z.strictObject({
             repoRoot: repo,
             releaseUnowned: z.boolean().optional(),
@@ -613,6 +621,8 @@ export function registerWorktreeTools(server, service) {
                     language: input.language,
                 }),
             });
+            if (askFailed(form))
+                return form;
             const decision = await service.questionnaireResume({
                 repoRoot: input.repoRoot,
                 questionnaireId,
@@ -634,9 +644,10 @@ export function registerWorktreeTools(server, service) {
             const retired = [];
             const kept = [];
             const refused = [];
+            const approved = [];
             for (const item of items) {
-                const questionnaireId = 'worktree-retire-' + sha256(item.repoRoot + item.generation);
                 const missing = item.reasons.includes('worktree directory missing');
+                const questionnaireId = retireQuestionId(item, !missing, input.decisionAttempt);
                 const folder = basename(item.repoRoot);
                 const definition = (turkish) => {
                     const copy = retireCopy[turkish ? 'tr' : 'en'];
@@ -677,20 +688,30 @@ export function registerWorktreeTools(server, service) {
                     ],
                 });
                 const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
+                if (askFailed(form)) {
+                    refused.push({
+                        repoRoot: item.repoRoot,
+                        message: 'This folder was not asked about and nothing was removed: the decision stored under its question could not be opened.',
+                    });
+                    continue;
+                }
                 const decision = await service.questionnaireResume({
                     repoRoot: input.repoRoot,
                     questionnaireId,
                 });
                 if (decision.status !== 'answered')
                     return form;
-                if (decision.answer?.choice !== 'retire') {
+                if (decision.answer?.choice === 'retire')
+                    approved.push({ item, questionnaireId });
+                else
                     kept.push(item.repoRoot);
-                    continue;
-                }
+            }
+            for (const { item, questionnaireId } of approved) {
                 const result = await service.worktreeOperation('retire', {
                     repoRoot: input.repoRoot,
                     worktreePath: item.repoRoot,
                     generation: item.generation,
+                    decisionAttempt: input.decisionAttempt,
                     decisionId: questionnaireId,
                 });
                 if (result.ok)
@@ -753,6 +774,8 @@ export function registerWorktreeTools(server, service) {
             ],
         });
         const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
+        if (askFailed(form))
+            return form;
         const decision = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId,
@@ -857,6 +880,8 @@ export function registerWorktreeTools(server, service) {
                 ],
         });
         const form = await askQuestionnaire(server, service, { ...definition(language === 'tr'), repoRoot: input.repoRoot }, context, [definition(language !== 'tr'), previous(true), previous(false)]);
+        if (askFailed(form))
+            return form;
         const decision = await service.questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId,

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

@@ -6,7 +6,7 @@ import { lstat, readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { SourceSnapshot } from '../git/source-snapshot.js';
 import { ProjectIntake } from '../project/project-intake.js';
-import { canonicalPath } from '../utilities/files.js';
+import { canonicalPath, pathExists } from '../utilities/files.js';
 import { minimatch } from 'minimatch';
 import { endpoints } from '../config.js';
 import { startPhaseTimer } from './phase-timer.js';
@@ -2444,9 +2444,10 @@ export class BridgeService {
             }
             if (operation === 'retire') {
                 const entry = input.worktreePath ? await pool.forPath(projectId, input.worktreePath) : null;
+                const folderPresent = entry ? await pathExists(entry.repoRoot) : false;
                 if (!entry ||
                     entry.generation !== input.generation ||
-                    input.decisionId !== 'worktree-retire-' + sha256(entry.repoRoot + entry.generation))
+                    input.decisionId !== retireQuestionId(entry, folderPresent, input.decisionAttempt ?? 0))
                     throw refuse('The retired folder changed after its removal was asked about. List the worktrees again.', 'worktree.list');
                 const decision = await this.questionnaireResume({
                     repoRoot: repository.repoRoot,
@@ -2454,7 +2455,7 @@ export class BridgeService {
                 });
                 if (decision.status !== 'answered' || decision.answer?.choice !== 'retire')
                     throw refuse('A retired folder is removed only after the user approves it in the native worktree.reconcile form.', 'worktree.reconcile');
-                await pool.retire(projectId, repository.repoRoot, entry.repoRoot, entry.generation);
+                await pool.retire(projectId, repository.repoRoot, entry.repoRoot, entry.generation, folderPresent);
                 return asJsonValue({ operation, complete: true, removed: entry.repoRoot });
             }
             const entry = await pool.forPath(projectId, repository.repoRoot);
@@ -3544,21 +3545,30 @@ export class BridgeService {
         }
     }
     async actionableWorkItems(projectId) {
+        const path = `${endpoints.workItemList(projectId)}?limit=100`;
         try {
-            const response = await this.dependencies.client.request(`${endpoints.workItemList(projectId)}?limit=100`);
-            const items = objectValue(response.data)?.items;
-            if (!Array.isArray(items))
+            const chosen = await this.workItemPage(`${path}&actionable=true`).catch((error) => {
+                if (error instanceof ApiResponseError && error.httpStatus === 400)
+                    return null;
+                throw error;
+            });
+            if (chosen && chosen.length > 0)
+                return chosen;
+            const every = await this.workItemPage(path);
+            if (chosen && every.some((entry) => objectValue(objectValue(entry)?.projectStatus) !== null))
                 return [];
             const actionable = new Set(['backlog', 'ready', 'in_progress', 'in_review']);
-            return items.filter((entry) => {
-                const item = objectValue(entry);
-                return item ? actionable.has(String(item.status)) : false;
-            });
+            return every.filter((entry) => actionable.has(String(objectValue(entry)?.status)));
         }
         catch {
             return [];
         }
     }
+    async workItemPage(path) {
+        const response = await this.dependencies.client.request(path);
+        const items = objectValue(response.data)?.items;
+        return Array.isArray(items) ? items : [];
+    }
     async clientUpdate(authenticated) {
         const installed = this.dependencies.clientVersion;
         if (!authenticated) {
@@ -5057,6 +5067,13 @@ export function cancelledDeliveryQuestionId(entry, clean) {
     return ('worktree-delivery-cancel-' +
         sha256(entry.generation + ':' + (clean ? 'clean' : entry.managed ? 'modified' : 'own-folder')));
 }
+export function retireQuestionId(entry, folderPresent, decisionAttempt) {
+    return ('worktree-retire-' +
+        sha256(entry.repoRoot +
+            entry.generation +
+            (folderPresent ? '' : ':record') +
+            (decisionAttempt ? ':' + decisionAttempt : '')));
+}
 function refuse(message, recovery, details) {
     return new BridgeRecoveryError(message, recovery, details);
 }

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

@@ -429,7 +429,7 @@ export class WorktreePool {
             await this.save(registry);
         });
     }
-    async retire(projectId, repoRoot, path, generation) {
+    async retire(projectId, repoRoot, path, generation, folderPresent) {
         const commonDir = await this.commonDirectory(repoRoot);
         const activeRoot = key(await this.documentsDirectory());
         const legacyRoot = await this.legacyDocumentsDirectory();
@@ -443,7 +443,10 @@ export class WorktreePool {
                 entry.commonDir !== commonDir ||
                 !this.outsideActiveRoot(entry, activeRoot, legacyRoot))
                 throw refuse('This folder is no longer the same retired slot. List the worktrees again before removing it.');
-            if (await pathExists(entry.repoRoot)) {
+            const present = await pathExists(entry.repoRoot);
+            if (present !== folderPresent)
+                throw refuse('The retired folder changed after its removal was asked about. List the worktrees again.');
+            if (present) {
                 const reasons = await this.fileProtection(entry);
                 if (reasons.length)
                     throw refuse('The retired folder is protected: ' +

package/bin/entry-point.test.mjs

@@ -1,29 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
-import test from 'node:test';
-
-const entryPoint = new URL('./engineering-memory.mjs', import.meta.url);
-const manifest = new URL('../package.json', import.meta.url);
-
-test('the published entry point tells the installer which version it is', async () => {
-  const source = await readFile(entryPoint, 'utf8');
-
-  assert.match(
-    source,
-    /'--client-version',\s*await publishedVersion\(\)/,
-    'The installer is never told the version, so every install reports itself as unknown and no update is ever offered',
-  );
-});
-
-test('the published entry point tells the installer which backend it was built for', async () => {
-  const source = await readFile(entryPoint, 'utf8');
-
-  assert.match(source, /'--api-url',\s*await publishedApiUrl\(\)/);
-});
-
-test('the manifest carries a version the entry point can stamp', async () => {
-  const declared = JSON.parse(await readFile(manifest, 'utf8'));
-
-  assert.match(String(declared.version), /^\d+\.\d+\.\d+$/);
-  assert.equal(declared.name, 'engineering-memory');
-});