engineering-memory 1.11.16 → 1.11.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.16",
+  "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": "9623849ae66a8cc72716533cb131790a4c517ac7"
+  "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

@@ -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/skill/references/lifecycle.md

@@ -73,6 +73,14 @@ One WorkItem UUID coordinates independent EngineeringTask runs, one per selected
 
 Open each side with the same workItemId and its own repository binding when work reaches that side. Each side has its own lease, reconciliation, verify, close and commit gate. Check `work_item.runs` and sibling checkpoints when handing off; one side completing does not prove all selected projects are complete. A plan's scope and branch cannot change while an implementation run is active. Read-only analysis does not acquire application write rights; its later write transition must satisfy discipline and the confirmed plan.
 
+### Work item statuses
+
+Read `work_item.statuses` before choosing a status for `work_item.update` or filtering `work_item.list`. The catalogue belongs to the project: follow its user-defined `meaning`, `entryRule` and flags. Never infer workflow from a name or translate statuses into the old six-value set. Send the actual catalogue slug. A work item's `status` is that slug, or null when its status link is invalid.
+
+The catalogue returns `items`, `total`, `offset` and `limit`. Page with `offset` (default 0) and `limit` (default 50, maximum 100); use `includeArchived: true` to inspect retained archived statuses. Each row includes `id`, `slug`, `name`, `category`, `isInitial`, `isActionable`, `isParked`, `isTerminal`, `archivedAt`, `meaning`, `entryRule`, `position` and `lockVersion`. The work item's nested `projectStatus` remains its compact nine-field summary. `work_item.list` also accepts `offset` and `limit`; a status filter matches the actual slug, including retained archived statuses, and an unknown slug returns an empty page. Its `includeArchived` option concerns work items.
+
+Session entry uses the backend's actionable selection. An empty page remains empty, and a failed lookup offers no work items; never retry an unfiltered list to classify statuses locally. Reuse existing user choices. Any unresolved workflow choice must use the native questionnaire.
+
 ### Administration, product management and QA
 
 Administrative authority and work discipline are independent. Organization admins can manage projects, assignments, repository URLs and work items in their organization. A global admin has those rights only in organizations they actively belong to. Ordinary users need a live explicit project assignment. Active organization administrators, including a global admin with live membership in that organization, inherit contributor access to its projects without a separate project grant. Fullstack/backend/web/mobile/frontend disciplines still govern implementation, while project overrides do not grant administration.