engineering-memory 1.11.22 → 1.11.24

package/runtime/dist/src/mcp/live-status-tools.js

@@ -0,0 +1,37 @@
+import * as z from 'zod/v4';
+const sharing = z.enum(['managers', 'off']);
+export function registerLiveStatusTools(server, service) {
+    server.registerTool('live_status.list', {
+        description: 'Show who is working on which Engineering Memory task right now: its stage, whether it is waiting for an answer, which AI tool runs it and when it last acted. Scope it to one project or one organization; with neither it uses the project bound here. It returns identifiers only — people are user ids: project.member_list gives each one’s role and discipline (names are not available to agents), and work_item.get gives a work item’s key and title; resolve them before showing anything to the user. Nobody’s questions, answers, code, file names, branches or chat are in it.',
+        inputSchema: z
+            .strictObject({
+            repoRoot: z.string().min(1).optional(),
+            projectId: z.uuid().optional(),
+            organizationId: z.uuid().optional(),
+        })
+            .refine((value) => !(value.projectId && value.organizationId), 'Choose one projectId or organizationId, or neither for the bound project.'),
+    }, async (input) => output(await service.liveStatusList(input)));
+    server.registerTool('live_status.notice_presented', {
+        description: 'Silently record that the live task status notice session.entry returned was shown to the user, with that exact noticeVersion. This is a presentation receipt, never their agreement, and it changes nothing about what is shared. A presented:false answer means the version sent is not a notice version, so nothing was recorded and there is nothing to do: never retry it and never raise it with the user.',
+        inputSchema: z.strictObject({
+            repoRoot: z.string().min(1).optional(),
+            projectId: z.uuid().optional(),
+            noticeVersion: z.string().regex(/^[0-9a-f]{64}$/),
+        }),
+    }, async (input) => output(await service.liveStatusNoticePresented(input)));
+    server.registerTool('live_status.set_sharing', {
+        description: 'Change who sees live task status in one organization: managers lets the owners and maintainers of each project and the owners of the organization see its tasks, off leaves every task visible only to the person doing it. Call it only when the user asks for that change; pass the sharing you read as expectedSharing so a change someone else made is not overwritten. Organization owners only.',
+        inputSchema: z.strictObject({
+            organizationId: z.uuid(),
+            sharing,
+            expectedSharing: sharing,
+        }),
+    }, async (input) => output(await service.liveStatusSetSharing(input)));
+}
+function output(result) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+        isError: !result.ok,
+    };
+}
+//# sourceMappingURL=live-status-tools.js.map

package/runtime/dist/src/mcp/server.js

@@ -12,6 +12,7 @@ export function createMcpServer() {
     });
 }
 export function registerAllTools(host, service) {
+    service.live.useHost(() => host.server.getClientVersion()?.name);
     registerEngineeringMemoryTools(host, service);
     registerQuestionnaireTools(host, service);
     registerOnboardingTools(host, service);

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

@@ -77,6 +77,7 @@ export const toolAnnotations = {
     'task.resolve_pending_delivery': destructive, // discards a pending delivery
     'task.verify': write,
     'task.close': write,
+    'task.delivery': write,
     'task.abandon': destructive,
     'task.branch': outward, // fetches the chosen base from the Git remote
     'architecture.plan': read,
@@ -102,6 +103,8 @@ export const toolAnnotations = {
     'work_item.runs': read,
     'work_item.record_test': write,
     'work_item.test_results': read,
+    'work_item.comment': write,
+    'work_item.comments': read,
     'work_item.plan': read,
     'work_item.confirm_plan': write,
     'project.update': write,
@@ -122,6 +125,9 @@ export const toolAnnotations = {
     'project.link': write,
     'project.unlink': destructive,
     'project.links': read,
+    'live_status.list': read,
+    'live_status.notice_presented': repeatableWrite,
+    'live_status.set_sharing': write,
     'auth.status': read,
     'auth.signin_browser': outward,
     'auth.logout': destructive,

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

@@ -1,4 +1,5 @@
 import { registerDeliveryTools } from './delivery-tools.js';
+import { registerLiveStatusTools } from './live-status-tools.js';
 import { registerStatusMeaningTools } from './status-meaning-tools.js';
 import { registerStatusRemapTools } from './status-remap-tools.js';
 import { registerWorkflowTools } from './workflow-tools.js';
@@ -115,6 +116,7 @@ export const engineeringMemoryToolNames = [
     'task.resolve_pending_delivery',
     'task.verify',
     'task.close',
+    'task.delivery',
     'task.abandon',
     'task.branch',
     'architecture.plan',
@@ -140,6 +142,8 @@ export const engineeringMemoryToolNames = [
     'work_item.runs',
     'work_item.record_test',
     'work_item.test_results',
+    'work_item.comment',
+    'work_item.comments',
     'work_item.plan',
     'work_item.confirm_plan',
     'project.update',
@@ -160,6 +164,9 @@ export const engineeringMemoryToolNames = [
     'project.link',
     'project.unlink',
     'project.links',
+    'live_status.list',
+    'live_status.notice_presented',
+    'live_status.set_sharing',
     'auth.status',
     'auth.signin_browser',
     'auth.logout',
@@ -969,7 +976,7 @@ export function registerEngineeringMemoryTools(server, service) {
             ...workItemLocator,
             data: z.object({
                 expectedVersion: z.number().int().min(1),
-                idempotencyKey: z.string().uuid(),
+                idempotencyKey: z.uuidv4(),
                 outcome: z.enum(['passed', 'failed', 'blocked']),
                 summary: z.string().trim().min(2).max(4000),
                 testedRevision: z.string().min(1).max(160).optional(),
@@ -984,6 +991,24 @@ export function registerEngineeringMemoryTools(server, service) {
             limit: z.number().int().min(1).max(100).optional(),
         }),
     }, async (input) => toolResult(await service.workItemTestResults(input)));
+    server.registerTool('work_item.comment', {
+        description: 'Write a comment on an authorized work item, such as the reason a tester sent it back to Rework. Comments are permanent: correct one with a new comment. Reuse the same idempotency key only for an identical retry.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            data: z.object({
+                idempotencyKey: z.uuidv4(),
+                body: z.string().trim().min(1).max(4000),
+            }),
+        }),
+    }, async (input) => toolResult(await service.workItemComment(input)));
+    server.registerTool('work_item.comments', {
+        description: 'Read the comments of an authorized work item, newest first. Read them before starting a round on work that came back from testing.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            offset: z.number().int().min(0).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+        }),
+    }, async (input) => toolResult(await service.workItemComments(input)));
     server.registerTool('work_item.plan', {
         description: 'Inspect authorized current and linked project targets, repository URLs, implementation capabilities and the persisted shared branch before opening work. Check contracts to identify backend/web/mobile impact; capability is not user consent.',
         inputSchema: z.object(workItemLocator),
@@ -1207,6 +1232,7 @@ export function registerEngineeringMemoryTools(server, service) {
         description: 'List the projects linked to this one, and which side of the product each is.',
         inputSchema: z.object({ projectId: z.string().min(1) }),
     }, async (input) => toolResult(await service.projectLinks(input)));
+    registerLiveStatusTools(server, service);
     server.registerTool('auth.status', {
         description: 'Check whether OS credential storage contains an active local Engineering Memory session.',
         inputSchema: z.object({}),

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

@@ -30,6 +30,8 @@ function deferredStart(input, questionnaireId) {
                     name: input.name,
                     base: input.base,
                     keepCurrent: input.keepCurrent,
+                    workItemId: input.workItemId,
+                    workItemProjectId: input.workItemProjectId,
                 },
             },
             nextAction: `Nothing was created, reserved or saved. Tell the user in one line that starting ${input.externalTaskId} is on hold. Continue only read-only work. When the user wants to start, call reconsider exactly as given; it asks the start form again.`,
@@ -285,7 +287,7 @@ export function registerWorktreeTools(server, service) {
         inputSchema: z.strictObject(policy),
     }, async (input) => output(await service.worktreePolicy(json(input))));
     server.registerTool('task.branch', {
-        description: 'Start a write task by selecting its decision mode in one short native form, then resolve two short questions for the starting branch (unless base is given) and the folder. A unique branch name is generated automatically unless name is supplied. Folder options: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, named in the option), this folder on its current branch, or not now. Nothing is created until a valid native or mode-delegated start answer is recorded; the next call with the same arguments allocates. A remote base is fetched and its exact commit pinned. Retry/resume preserves the allocation. Not now returns status deferred with the exact reconsider call; retries keep the same decisionAttempt. Use the returned repoRoot for ALL commands. A read-only task allocates only when transitioning to write.',
+        description: 'Start a write task by selecting its decision mode in one short native form, then resolve two short questions for the starting branch (unless base is given) and the folder. A unique branch name is generated automatically unless name is supplied. Pass workItemId (and workItemProjectId when the item lives in a linked project) for work on a work item: the branch question then also offers continuing the branch of its plan or of its earlier rounds, fetched from origin when this clone lacks it, and a planned item that has no branch yet gets its plan branch as the new name. Folder options: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, named in the option), this folder on its current branch, or not now. Nothing is created until a valid native or mode-delegated start answer is recorded; the next call with the same arguments allocates. A remote base is fetched and its exact commit pinned. Retry/resume preserves the allocation. Not now returns status deferred with the exact reconsider call; retries keep the same decisionAttempt. Use the returned repoRoot for ALL commands. A read-only task allocates only when transitioning to write.',
         inputSchema: z.strictObject({
             repoRoot: repo,
             externalTaskId: z.string().min(2).max(160),
@@ -293,6 +295,8 @@ export function registerWorktreeTools(server, service) {
             name: branch.optional(),
             base: baseSchema.optional(),
             keepCurrent: z.boolean().optional(),
+            workItemId: z.string().uuid().optional(),
+            workItemProjectId: z.string().uuid().optional(),
             language: languageTag.optional(),
             presentation,
         }),
@@ -319,9 +323,14 @@ export function registerWorktreeTools(server, service) {
                     recovery: 'task.branch',
                 },
             });
+        const plan = flight.planBranch;
         const { previous, ...definition } = taskStartDefinition({
             ...input,
             ...flight,
+            ...(plan ? { name: plan } : {}),
+            ...(plan && flight.continueBranches.includes(plan)
+                ? { base: { kind: 'existing', branch: plan } }
+                : {}),
             language: told ?? 'en',
         });
         const owner = {
@@ -333,6 +342,8 @@ export function registerWorktreeTools(server, service) {
                 name: input.name,
                 base: input.base,
                 keepCurrent: input.keepCurrent,
+                workItemId: input.workItemId,
+                workItemProjectId: input.workItemProjectId,
             }),
         };
         const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, previous, owner);
@@ -359,7 +370,10 @@ export function registerWorktreeTools(server, service) {
                 recovery: 'task.branch',
             },
         });
-        if (choice.name && choice.name !== input.name && choice.name !== flight.suggestedName) {
+        if (choice.name &&
+            choice.base.kind !== 'existing' &&
+            choice.name !== input.name &&
+            choice.name !== flight.suggestedName) {
             const unusable = await service.unusableBranchName(input.repoRoot, choice.name);
             if (unusable)
                 return reconsider(unusable);

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

@@ -8,6 +8,7 @@ export const backendRecoveryOperationNames = [
     'auth.web_csrf',
     'auth.web_signin',
     'audit.list',
+    'live_status.list',
     'organization.member_list',
     'organization.member_upsert',
     'project.setup',
@@ -23,6 +24,8 @@ export const backendRecoveryOperationNames = [
     'work_item.statuses',
     'work_item.workflow',
     'work_item.get',
+    'work_item.comment',
+    'work_item.comments',
     'session.bootstrap',
     'session.resume',
     'context.refresh',
@@ -47,6 +50,7 @@ export const backendRecoveryOperationNames = [
     'task.abandon',
     'task.branch',
     'task.resolve_pending_delivery',
+    'task.delivery',
 ];
 const backendRecoveryOperations = new Set(backendRecoveryOperationNames);
 const browserSigninRecovery = 'auth.signin_browser';
@@ -119,6 +123,9 @@ export class ApiClient {
                 throw new ApiResponseError('Authentication is required. Recovery: call auth.signin_browser.', 401, null, false, null, browserSigninRecovery);
             }
             headers.Authorization = `Bearer ${accessToken}`;
+            const live = this.options.liveHeader?.(path);
+            if (live)
+                headers['x-em-live'] = live;
         }
         const requestSignal = request.networkTimeoutMs === undefined
             ? request.signal

package/runtime/dist/src/runtime/branch-preferences.js

@@ -1,5 +1,20 @@
 import { BridgeRecoveryError } from './recovery-error.js';
 export async function resolveTaskBase(git, repoRoot, base, preferences) {
+    if (base.kind === 'existing') {
+        const local = await git.sourceIdentity(repoRoot, 'refs/heads/' + base.branch);
+        const fetched = await git.fetchBranchCommit(repoRoot, 'origin', base.branch).catch(() => null);
+        const tip = !fetched ||
+            (local && (await git.isAncestor(repoRoot, fetched.sourceCommit, local.sourceCommit)))
+            ? local
+            : !local || (await git.isAncestor(repoRoot, local.sourceCommit, fetched.sourceCommit))
+                ? fetched
+                : null;
+        if (!tip)
+            throw new BridgeRecoveryError(local
+                ? `Branch ${base.branch} here and on origin went separate ways, so it cannot simply be continued. Bring the two together with Git, or call task.branch with a new decisionAttempt and start a new branch.`
+                : `Branch ${base.branch} is neither in this clone nor on origin, so it cannot be continued. Call task.branch with a new decisionAttempt and start a new branch.`, 'task.branch');
+        return { ...tip, base };
+    }
     if (base.kind === 'current' || base.kind === 'local') {
         const source = await git.sourceIdentity(repoRoot, base.kind === 'current' ? (base.commit ?? 'HEAD') : base.ref);
         if (!source && base.kind === 'current' && !base.commit)