engineering-memory 1.11.15 → 1.11.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.15",
+  "version": "1.11.17",
   "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": "52f278262fad1afde8d11aa6e2343b3de5e8fe78"
+  "gitHead": "42ef1e9f90ef7b9d729457c45be97b755c737d1c"
 }

package/runtime/dist/src/config.js

@@ -77,6 +77,7 @@ export const endpoints = {
     projectRestore: (projectId) => `/projects/${projectId}/restore`,
     projectMemberAdd: (projectId) => `/projects/${projectId}/members`,
     projectMemberList: (projectId) => `/projects/${projectId}/members`,
+    workItemStatuses: (projectId) => `/projects/${projectId}/work-items/statuses`,
     workItemList: (projectId) => `/projects/${projectId}/work-items`,
     workItemGet: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}`,
     projectLink: '/projects/link',

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

@@ -100,6 +100,7 @@ export const toolAnnotations = {
     'work_item.confirm_plan': write,
     'project.update': write,
     'work_item.list': read,
+    'work_item.statuses': read,
     'work_item.get': read,
     'project.clone': outward,
     'project.link': write,

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

@@ -130,6 +130,7 @@ export const engineeringMemoryToolNames = [
     'work_item.plan',
     'work_item.confirm_plan',
     'project.update',
+    'work_item.statuses',
     'work_item.list',
     'work_item.get',
     'project.clone',
@@ -932,7 +933,7 @@ 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. 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.",
+        description: 'Edit or assign a work item at its current version. Assignees must already be active project members; this does not grant project access. Read work_item.statuses before changing status. Send the actual project catalogue slug and follow its user-defined meaning, entryRule and flags; never infer workflow from a status name.',
         inputSchema: z.object({
             ...workItemLocator,
             data: z.object({
@@ -1015,11 +1016,22 @@ export function registerEngineeringMemoryTools(server, service) {
             }),
         }),
     }, async (input) => toolResult(await service.projectUpdate(input)));
+    server.registerTool('work_item.statuses', {
+        description: 'Read the project status catalogue before choosing a work item status. Follow the user-defined meaning, entryRule and flags; never infer workflow from status names. Page with offset and limit (defaults 0 and 50, maximum 100). Archived statuses are excluded unless includeArchived is true.',
+        inputSchema: z.object({
+            projectId: z.string().uuid(),
+            offset: z.number().int().min(0).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+            includeArchived: z.boolean().optional(),
+        }),
+    }, async (input) => toolResult(await service.workItemStatuses(input)));
     server.registerTool('work_item.list', {
-        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.",
+        description: 'List selectable work items for a project before opening an engineering run in this chat. Read work_item.statuses for the actual project catalogue slugs and user-defined meanings; never infer workflow from status names. The status filter matches an actual slug, including a retained archived status; an unknown slug returns an empty page.',
         inputSchema: z.object({
             projectId: z.string().uuid(),
             status: z.string().trim().min(1).max(64).optional(),
+            offset: z.number().int().min(0).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
             priority: z.enum(['lowest', 'low', 'medium', 'high', 'highest']).optional(),
             assigneeUserId: z.string().uuid().optional(),
             includeArchived: z.boolean().optional(),

package/runtime/dist/src/runtime/api-client.js

@@ -20,6 +20,7 @@ export const backendRecoveryOperationNames = [
     'organization.list',
     'project.member_add',
     'work_item.list',
+    'work_item.statuses',
     'work_item.get',
     'session.bootstrap',
     'session.resume',

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

@@ -544,7 +544,7 @@ export class BridgeService {
                 if ((!sourceCommit && !(previous && previous.baseCommit === null && !previous.managed)) ||
                     branch === undefined)
                     throw refuse('The task branch and base must be restored before resuming its worktree.', 'worktree.reconcile');
-                const allocation = await pool.allocate({
+                const allocation = await pool.prepare(await pool.allocate({
                     projectId,
                     projectName: projectId,
                     repoFingerprint: repository.repoFingerprint,
@@ -554,7 +554,7 @@ export class BridgeService {
                     baseCommit: sourceCommit ?? null,
                     keepCurrent: previous ? !previous.managed : false,
                     resume: true,
-                }, await this.poolPolicy());
+                }, await this.poolPolicy()));
                 await pool.bind(projectId, allocation.repoRoot, allocation.generation, pointer.taskId);
                 allocation.taskId = pointer.taskId;
                 this.poolAllocations.set(allocation.repoRoot, allocation);
@@ -2615,7 +2615,7 @@ export class BridgeService {
         const allocationTimer = startPhaseTimer('task.branch.allocate');
         const allocationPolicy = await this.poolPolicy(true);
         allocationTimer.mark('policy');
-        const allocation = await pool.allocate({
+        const allocation = await pool.prepare(await pool.allocate({
             projectId,
             projectName: preferences.projectName ?? projectId,
             repoFingerprint: repository.repoFingerprint,
@@ -2626,7 +2626,7 @@ export class BridgeService {
             keepCurrent: input.keepCurrent,
             inPlace: !existing && input.inPlace,
             resume: Boolean(existing),
-        }, allocationPolicy);
+        }, allocationPolicy));
         allocationTimer.mark('pool_allocate');
         allocationTimer.finish();
         this.poolAllocations.set(allocation.repoRoot, allocation);
@@ -2648,7 +2648,7 @@ export class BridgeService {
         return asJsonValue({
             ...allocation,
             kept: !allocation.managed,
-            nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Use task.heartbeat during long work. Pause before handing the task to another client.',
+            nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Inspect readiness separately: a file problem does not cancel the task, and an editor request does not prove its window is visible. Resolve reported local file issues without overwriting existing files, then retry task.branch or session.resume. Use task.heartbeat during long work and pause before handoff.',
         });
     }
     adoptOwned(repoRoot, entry) {
@@ -3077,6 +3077,19 @@ export class BridgeService {
             });
         });
     }
+    async workItemStatuses(input) {
+        return this.execute(async () => {
+            const query = new URLSearchParams({
+                offset: String(input.offset ?? 0),
+                limit: String(input.limit ?? 50),
+            });
+            if (input.includeArchived !== undefined) {
+                query.set('includeArchived', String(input.includeArchived));
+            }
+            const response = await this.dependencies.client.request(`${endpoints.workItemStatuses(input.projectId)}?${query.toString()}`);
+            return asJsonValue(response.data);
+        });
+    }
     async workItemList(input) {
         return await this.execute(async () => {
             const query = new URLSearchParams();
@@ -3089,6 +3102,10 @@ export class BridgeService {
             }
             if (input.includeArchived)
                 query.set('includeArchived', 'true');
+            if (input.offset !== undefined)
+                query.set('offset', String(input.offset));
+            if (input.limit !== undefined)
+                query.set('limit', String(input.limit));
             const suffix = query.size > 0 ? `?${query.toString()}` : '';
             const response = await this.dependencies.client.request(`${endpoints.workItemList(input.projectId)}${suffix}`);
             return asJsonValue({
@@ -3551,30 +3568,15 @@ export class BridgeService {
         }
     }
     async actionableWorkItems(projectId) {
-        const path = `${endpoints.workItemList(projectId)}?limit=100`;
         try {
-            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 every.filter((entry) => actionable.has(String(objectValue(entry)?.status)));
+            const response = await this.dependencies.client.request(`${endpoints.workItemList(projectId)}?limit=100&actionable=true`);
+            const items = objectValue(response.data)?.items;
+            return Array.isArray(items) ? items : [];
         }
         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) {

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

@@ -0,0 +1,184 @@
+import { spawn } from 'node:child_process';
+import { constants } from 'node:fs';
+import { access, open, realpath, stat } from 'node:fs/promises';
+import { delimiter, dirname, isAbsolute, join, resolve } from 'node:path';
+export var WorktreeEditorStatus;
+(function (WorktreeEditorStatus) {
+    WorktreeEditorStatus["Requested"] = "requested";
+    WorktreeEditorStatus["Unavailable"] = "unavailable";
+    WorktreeEditorStatus["Failed"] = "failed";
+    WorktreeEditorStatus["Skipped"] = "skipped";
+})(WorktreeEditorStatus || (WorktreeEditorStatus = {}));
+export async function openWorktreeInEditor(repoRoot) {
+    if (!['win32', 'darwin', 'linux'].includes(process.platform) ||
+        (process.env.CI && !/^(false|0)$/i.test(process.env.CI)) ||
+        process.env.SSH_CONNECTION ||
+        process.env.SSH_CLIENT ||
+        process.env.SSH_TTY ||
+        process.env.VSCODE_AGENT_FOLDER ||
+        process.env.VSCODE_REMOTE_NAME ||
+        process.env.WSL_DISTRO_NAME ||
+        process.env.CODESPACES === 'true' ||
+        process.env.SESSIONNAME?.toLowerCase() === 'services' ||
+        (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY)) {
+        return {
+            status: WorktreeEditorStatus.Skipped,
+            detail: 'A local desktop session is not available.',
+        };
+    }
+    let folder;
+    try {
+        if (!repoRoot.trim())
+            throw new Error();
+        folder = await realpath(resolve(repoRoot));
+        if (!(await stat(folder)).isDirectory())
+            throw new Error();
+    }
+    catch {
+        return {
+            status: WorktreeEditorStatus.Failed,
+            detail: 'The worktree folder is not accessible.',
+        };
+    }
+    const command = await findEditor().catch(() => null);
+    if (!command) {
+        return {
+            status: WorktreeEditorStatus.Unavailable,
+            detail: 'An installed local VS Code CLI was not found.',
+        };
+    }
+    if (/[\\/](?:\.vscode-server(?:-insiders)?|remote-cli)[\\/]/i.test(command.executable)) {
+        return {
+            status: WorktreeEditorStatus.Skipped,
+            detail: 'The available VS Code CLI belongs to a remote session.',
+        };
+    }
+    const env = { ...process.env };
+    delete env.VSCODE_DEV;
+    if (process.platform === 'win32')
+        env.ELECTRON_RUN_AS_NODE = '1';
+    try {
+        return await new Promise((resolveResult) => {
+            const child = spawn(command.executable, [...command.args, '--new-window', folder], {
+                cwd: folder,
+                env,
+                shell: false,
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let settled = false;
+            let outputBytes = 0;
+            const timer = setTimeout(() => stop('The VS Code request timed out; window state is unknown.'), 10_000);
+            const finish = (status, detail) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                child.stdout.destroy();
+                child.stderr.destroy();
+                child.unref();
+                resolveResult({ status, detail });
+            };
+            const stop = (detail) => {
+                if (settled)
+                    return;
+                try {
+                    child.kill('SIGKILL');
+                }
+                finally {
+                    finish(WorktreeEditorStatus.Failed, detail);
+                }
+            };
+            const discardOutput = (chunk) => {
+                outputBytes += chunk.length;
+                if (outputBytes > 65_536) {
+                    stop('The VS Code CLI exceeded the output limit; window state is unknown.');
+                }
+            };
+            child.stdout.on('data', discardOutput);
+            child.stderr.on('data', discardOutput);
+            child.once('error', () => finish(WorktreeEditorStatus.Failed, 'The VS Code CLI could not start.'));
+            child.once('close', (code) => finish(code === 0 ? WorktreeEditorStatus.Requested : WorktreeEditorStatus.Failed, code === 0
+                ? 'VS Code launch requested; window state was not verified.'
+                : 'The VS Code CLI failed; window state is unknown.'));
+        });
+    }
+    catch {
+        return { status: WorktreeEditorStatus.Failed, detail: 'The VS Code CLI could not start.' };
+    }
+}
+async function findEditor() {
+    const directories = (process.env.PATH ?? '')
+        .split(delimiter)
+        .map((directory) => directory.replace(/^"(.+)"$/, '$1'))
+        .filter(isAbsolute)
+        .slice(0, 128);
+    if (process.platform === 'win32') {
+        for (const root of [
+            process.env.LOCALAPPDATA && join(process.env.LOCALAPPDATA, 'Programs'),
+            process.env.ProgramFiles,
+            process.env['ProgramFiles(x86)'],
+        ]) {
+            if (root && isAbsolute(root))
+                directories.push(join(root, 'Microsoft VS Code', 'bin'));
+        }
+    }
+    for (const directory of new Set(directories)) {
+        if (process.platform === 'win32') {
+            const command = await windowsEditor(directory);
+            if (command)
+                return command;
+        }
+        else {
+            const executable = join(directory, 'code');
+            if (await executableFile(executable)) {
+                return { executable: await realpath(executable), args: [] };
+            }
+        }
+    }
+    return null;
+}
+async function windowsEditor(bin) {
+    let handle;
+    try {
+        const launcher = await realpath(join(bin, 'code.cmd'));
+        handle = await open(launcher, 'r');
+        const info = await handle.stat();
+        if (!info.isFile() || info.size > 16_384)
+            return null;
+        const bytes = Buffer.alloc(16_385);
+        const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
+        if (bytesRead > 16_384)
+            return null;
+        const match = bytes
+            .subarray(0, bytesRead)
+            .toString('utf8')
+            .match(/^[ \t]*"%~dp0\.\.\\Code\.exe"[ \t]+"%~dp0\.\.\\((?:[a-f0-9]{7,40}\\)?resources\\app\\out\\cli\.js)"[ \t]+%\*[ \t]*\r?$/im);
+        if (!match)
+            return null;
+        const installation = resolve(dirname(launcher), '..');
+        const executable = join(installation, 'Code.exe');
+        const cli = join(installation, match[1]);
+        if (!(await executableFile(executable)) || !(await stat(cli)).isFile())
+            return null;
+        return { executable, args: [cli] };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function executableFile(path) {
+    try {
+        if (!(await stat(path)).isFile())
+            return false;
+        await access(path, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=worktree-editor.js.map