engineering-memory 1.11.18 → 1.11.20

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

@@ -0,0 +1,374 @@
+import * as z from 'zod/v4';
+import { languageTag } from '../runtime/questionnaire-store.js';
+import { assertSafeToPersist } from '../runtime/offline-outbox.js';
+import { sha256, stableStringify } from '../utilities/hash.js';
+import { answerChoice, answerData, askQuestionnaire } from './questionnaire-tools.js';
+const field = z.enum(['meaning', 'entryRule']);
+const navigation = z.tuple([z.string().trim().min(1).max(120), z.string().trim().min(1).max(200)]);
+const wording = z.strictObject({
+    fields: z.record(field, z.strictObject({
+        title: z.string().trim().min(1).max(80),
+        question: z.string().trim().min(1).max(240),
+        example: z.string().trim().min(1).max(400),
+        inputTitle: z.string().trim().min(1).max(120),
+    })),
+    context: z.string().trim().min(1).max(400),
+    current: z.string().trim().min(1).max(80),
+    proposed: z.string().trim().min(1).max(80),
+    empty: z.string().trim().min(1).max(80),
+    page: z.string().trim().min(1).max(80),
+    keep: navigation,
+    write: navigation,
+    clear: navigation,
+    next: navigation,
+    defer: navigation,
+    save: navigation,
+    review: z.strictObject({
+        message: z.string().trim().min(1).max(240),
+        context: z.string().trim().min(1).max(400),
+        example: z.string().trim().min(1).max(400),
+    }),
+});
+const inputSchema = z.strictObject({
+    repoRoot: z.string().min(1),
+    projectId: z.string().uuid(),
+    externalTaskId: z.string().trim().min(2).max(160),
+    statusId: z.string().uuid(),
+    expectedVersion: z.number().int().min(1).max(2147483647),
+    field,
+    draft: z.string().trim().max(4000).optional(),
+    recommendation: z.enum(['keep', 'write', 'clear']),
+    reason: z.string().trim().min(1).max(180),
+    requestKey: z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),
+    language: languageTag,
+    copy: wording.optional(),
+    decisionAttempt: z.number().int().min(1).max(10000).optional(),
+    presentation: z.literal('host_native').optional(),
+});
+const definition = z.object({
+    id: z.string().uuid(),
+    name: z.string().min(1).max(120),
+    slug: z.string().min(1).max(64),
+    meaning: z.string().max(4000),
+    entryRule: z.string().max(4000),
+    archivedAt: z.string().nullable(),
+    lockVersion: z.number().int().min(1).max(2147483647),
+});
+const pageSchema = z.object({
+    snapshot: z.string().regex(/^[a-f0-9]{64}$/),
+    items: z.array(definition).max(100),
+    total: z.number().int().min(0),
+    offset: z.number().int().min(0),
+    limit: z.literal(100),
+});
+const copies = {
+    tr: {
+        fields: {
+            meaning: {
+                title: 'Kolonun anlamı',
+                question: 'Bu kolondaki iş ne aşamada olur?',
+                inputTitle: 'Yazmak istediğin anlam',
+                example: 'İncelemede: geliştirme bitti; ekip arkadaşının kodu incelemesi bekleniyor.',
+            },
+            entryRule: {
+                title: 'Kolona giriş koşulu',
+                question: 'Bir iş bu kolona hangi koşulda alınır?',
+                inputTitle: 'Yazmak istediğin giriş koşulu',
+                example: 'İncelemeye geçmek için kod hazır ve ilgili testler başarılı olmalı.',
+            },
+        },
+        context: 'Bu adım isteğe bağlı. Yorum veya açıklama isteği kaydedilmez; yazdığın tanımı son incelemeden sonra kaydederiz.',
+        current: 'Mevcut metin',
+        proposed: 'Yeni metin',
+        empty: '(boş)',
+        page: 'Sayfa',
+        keep: ['Mevcut kalsın', 'Bu alanı ve mevcut işleri değiştirme.'],
+        write: [
+            'Tanımı yaz',
+            'Metin alanına kendi tanımını yaz; kaydetmeden önce birlikte gözden geçir.',
+        ],
+        clear: [
+            'Bu alanı boşalt',
+            'Boş bırakma tercihini son incelemede doğrula; diğer alanlar aynı kalır.',
+        ],
+        next: ['Devamını incele', 'Metnin sonraki kısmını göster; henüz hiçbir şey kaydetme.'],
+        defer: ['Şimdi kaydetme', 'Bu denemeyi ertele; kolon tanımını ve işleri değiştirme.'],
+        save: [
+            'Bu tanımı kaydet',
+            'İncelediğin alanı kaydet; diğer alanlara ve mevcut işlere dokunma.',
+        ],
+        review: {
+            message: 'Bu alanın değişikliğini incele',
+            context: 'Mevcut ve yeni metin tümüyle gösterilir. Uzunsa sonraki sayfaya geç; kaydetme yalnızca son sayfadadır. Bu işlem bir işi taşımaz veya olay çalıştırmaz.',
+            example: 'İncelemede kolonunu “kod hazır, inceleme bekleniyor” diye tanımlarsın. Kolondaki işler aynı yerde kalır.',
+        },
+    },
+    en: {
+        fields: {
+            meaning: {
+                title: 'Stage meaning',
+                question: 'What does work in this stage mean?',
+                inputTitle: 'Your stage meaning',
+                example: 'In Review: development is complete and a teammate needs to review the code.',
+            },
+            entryRule: {
+                title: 'Stage entry condition',
+                question: 'When should work enter this stage?',
+                inputTitle: 'Your entry condition',
+                example: 'Code must be ready and the relevant tests must pass before review.',
+            },
+        },
+        context: 'This step is optional. Feedback or requests for explanation do not save anything; a written definition is reviewed before saving.',
+        current: 'Current text',
+        proposed: 'New text',
+        empty: '(empty)',
+        page: 'Page',
+        keep: ['Keep the current value', 'Leave this field and existing work unchanged.'],
+        write: ['Write a definition', 'Enter your own text and review it before saving.'],
+        clear: ['Clear this field', 'Review an explicit empty value; other fields remain unchanged.'],
+        next: ['Review the next part', 'Show the next part of the text without saving anything yet.'],
+        defer: ['Do not save now', 'Defer this attempt without changing the stage or existing work.'],
+        save: [
+            'Save this definition',
+            'Save the reviewed field; other fields and existing work remain unchanged.',
+        ],
+        review: {
+            message: 'Review this field change',
+            context: 'All current and proposed text is shown. Continue through longer text; only the last page can save it. This does not move work or execute an event.',
+            example: 'Define In Review as “code is ready and awaiting review.” Tasks in that stage remain where they are.',
+        },
+    },
+};
+export function registerStatusMeaningTools(server, service) {
+    server.registerTool('work_item.describe_status', {
+        description: 'Optionally review a user-authored meaning or entry condition for one status at its exact version. Resume the bound write task first. Never infer text from the name or resurvey owner-authored defaults. Supply a deliberate keep/write/clear recommendation and reason in the conversation language. Without draft, an editable native field collects up to2000 characters; explicitly authored draft arguments support the full4000-character metadata contract through complete review pages. Feedback alone never writes. Every saved change requires exact final mode-governed review, and existing metadata authority/version checks. Retry identical input to resume; reconsider a skipped/deferred attempt only when authorized. Turkish/English copy is built in; other languages require complete copy. Does not move work or fire events.',
+        inputSchema,
+    }, (input, context) => describeStatus(server, service, input, context));
+}
+async function describeStatus(server, service, input, context) {
+    const scope = await service.workItemSetupContext(input);
+    if (!scope.ok)
+        return output(scope);
+    const { repoRoot: _repoRoot, ...retryArguments } = input;
+    try {
+        assertSafeToPersist(retryArguments, '', '', true);
+    }
+    catch {
+        return refusal('Remove sensitive text from the description and its retry arguments.', 'work_item.describe_status');
+    }
+    const primary = input.language.split('-')[0];
+    const copy = input.copy ?? (primary === 'tr' || primary === 'en' ? copies[primary] : undefined);
+    if (!copy)
+        return refusal('Supply every copy field in the conversation language.', 'work_item.describe_status');
+    let target;
+    let snapshot;
+    let total;
+    for (let offset = 0; total === undefined || offset < total; offset += 100) {
+        const response = await service.workItemWorkflow({
+            projectId: input.projectId,
+            offset,
+            limit: 100,
+            includeArchived: true,
+            ...(snapshot ? { snapshot } : {}),
+        });
+        if (!response.ok)
+            return output(response);
+        const parsed = pageSchema.safeParse(response.data);
+        if (!parsed.success)
+            return refusal('Reload the complete status definition before reviewing it.', 'work_item.statuses');
+        const page = parsed.data;
+        if (page.offset !== offset ||
+            (snapshot !== undefined && snapshot !== page.snapshot) ||
+            (total !== undefined && total !== page.total) ||
+            page.items.length !== Math.min(100, Math.max(0, page.total - offset)) ||
+            new Set(page.items.map((item) => item.id)).size !== page.items.length)
+            return refusal('The status pages changed or were incomplete. Reload the definition.', 'work_item.statuses');
+        snapshot = page.snapshot;
+        total = page.total;
+        target = page.items.find((item) => item.id === input.statusId);
+        if (target)
+            break;
+    }
+    if (!target || target.archivedAt !== null || target.lockVersion !== input.expectedVersion)
+        return refusal('The definition is unavailable, archived or changed. Read its current version before reviewing.', 'work_item.statuses');
+    try {
+        assertSafeToPersist({ label: target.name, slug: target.slug, value: target[input.field] }, '', '', true);
+    }
+    catch {
+        return refusal('The stored definition contains content that cannot be included in a durable question.', 'work_item.statuses');
+    }
+    const namespace = scope.data.namespace;
+    const { presentation: _presentation, ...decisionInput } = retryArguments;
+    const setupId = sha256(stableStringify({
+        namespace,
+        decisionInput,
+        current: target[input.field],
+        name: target.name,
+        slug: target.slug,
+        copy,
+    }));
+    const owner = {
+        tool: 'work_item.describe_status',
+        externalTaskId: input.externalTaskId,
+        decisionAttempt: input.decisionAttempt,
+        retryArguments,
+    };
+    let value = input.draft;
+    let inputQuestionnaireId = null;
+    if (value === undefined) {
+        inputQuestionnaireId = 'status-description-input-' + setupId;
+        const options = ['keep', 'write', 'clear'].map((id) => ({
+            id,
+            label: copy[id][0],
+            description: copy[id][1] + (id === input.recommendation ? ' ' + input.reason : ''),
+        }));
+        options.sort((a, b) => Number(b.id === input.recommendation) - Number(a.id === input.recommendation));
+        const question = {
+            questionnaireId: inputQuestionnaireId,
+            language: input.language,
+            impact: 'critical',
+            message: copy.fields[input.field].question + '\n' + target.name + ' (' + target.slug + ')',
+            context: copy.context,
+            example: copy.fields[input.field].example,
+            options,
+            textField: {
+                title: copy.fields[input.field].inputTitle,
+                maxLength: 2000,
+                requiredForChoice: 'write',
+            },
+            binding: {
+                setupId,
+                namespace,
+                projectId: input.projectId,
+                statusId: input.statusId,
+                expectedVersion: input.expectedVersion,
+                field: input.field,
+            },
+        };
+        const answer = await askQuestionnaire(server, service, { ...question, repoRoot: input.repoRoot, presentation: input.presentation }, context, [], owner);
+        const choice = answerChoice(answer);
+        if (!choice)
+            return answer;
+        if (choice === 'keep')
+            return deferred(input, 'skipped');
+        if (choice === 'clear')
+            value = '';
+        else if (choice === 'write')
+            value = answerData(answer)?.text;
+        if (value === undefined)
+            return refusal('Resume the exact editable description question.', 'questionnaire.resume');
+    }
+    if (value === target[input.field])
+        return output({ ok: true, data: { status: 'unchanged', applied: false } });
+    const proposal = {
+        projectId: input.projectId,
+        statusId: input.statusId,
+        expectedVersion: input.expectedVersion,
+        field: input.field,
+        value,
+    };
+    const proposalDigest = sha256(stableStringify(proposal));
+    const reviewText = copy.fields[input.field].title +
+        '\n' +
+        target.name +
+        ' (' +
+        target.slug +
+        ')\n\n' +
+        copy.current +
+        '\n' +
+        (target[input.field] || copy.empty) +
+        '\n\n' +
+        copy.proposed +
+        '\n' +
+        (value || copy.empty);
+    const pages = [];
+    for (let start = 0; start < reviewText.length;) {
+        let end = Math.min(start + 1400, reviewText.length);
+        const last = reviewText.charCodeAt(end - 1);
+        if (end < reviewText.length && last >= 0xd800 && last <= 0xdbff)
+            end--;
+        pages.push(reviewText.slice(start, end));
+        start = end;
+    }
+    const reviewQuestionnaireIds = pages.map((_, index) => 'status-description-review-' + sha256(stableStringify({ setupId, proposalDigest, index })));
+    for (let index = 0; index < pages.length; index++) {
+        if (context.mcpReq.signal.aborted)
+            return output({ ok: true, data: { status: 'pending', reason: 'interrupted' } });
+        const final = index === pages.length - 1;
+        const action = final ? copy.save : copy.next;
+        const question = {
+            questionnaireId: reviewQuestionnaireIds[index],
+            language: input.language,
+            impact: 'critical',
+            message: copy.review.message +
+                '\n\n' +
+                pages[index] +
+                '\n\n' +
+                copy.page +
+                ' ' +
+                (index + 1) +
+                '/' +
+                pages.length,
+            context: copy.review.context,
+            example: copy.review.example,
+            options: [
+                { id: final ? 'save' : 'continue', label: action[0], description: action[1] },
+                { id: 'defer', label: copy.defer[0], description: copy.defer[1] },
+            ],
+            binding: {
+                setupId,
+                namespace,
+                proposalDigest,
+                inputQuestionnaireId,
+                reviewQuestionnaireIds,
+                index,
+            },
+        };
+        const answer = await askQuestionnaire(server, service, { ...question, repoRoot: input.repoRoot, presentation: input.presentation }, context, [], owner);
+        const choice = answerChoice(answer);
+        if (choice === 'defer')
+            return deferred(input, 'deferred');
+        if (choice !== (final ? 'save' : 'continue'))
+            return answer;
+    }
+    return output(await service.workItemApplyStatusDescription({
+        ...proposal,
+        repoRoot: input.repoRoot,
+        externalTaskId: input.externalTaskId,
+        inputQuestionnaireId,
+        reviewQuestionnaireIds,
+    }));
+}
+function deferred(input, status) {
+    return output({
+        ok: true,
+        data: {
+            status,
+            applied: false,
+            ...(input.decisionAttempt === 10000
+                ? {}
+                : {
+                    reconsider: {
+                        tool: 'work_item.describe_status',
+                        arguments: { ...input, decisionAttempt: (input.decisionAttempt ?? 0) + 1 },
+                    },
+                }),
+            nextAction: input.decisionAttempt === 10000
+                ? 'This attempt remains deferred. Use a new requestKey only after reconsideration is explicitly authorized.'
+                : 'Identical retries preserve this decision. Reconsider only after explicit user intent or a reasoned current delegated decision.',
+        },
+    });
+}
+function refusal(message, recovery) {
+    return output({
+        ok: false,
+        error: { kind: 'status_description', message, recovery, retryable: false },
+    });
+}
+function output(result) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+        isError: !result.ok,
+    };
+}
+//# sourceMappingURL=status-meaning-tools.js.map

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

@@ -18,6 +18,7 @@ const outward = {
 export const toolAnnotations = {
     'project.git_preferences': read,
     'project.set_git_preferences': write,
+    'worktree.prepare_files': repeatableWrite,
     'worktree.policy': read,
     'worktree.set_policy': write,
     'worktree.list': read,
@@ -34,6 +35,8 @@ export const toolAnnotations = {
     'questionnaire.answer_from_host': repeatableWrite,
     'questionnaire.withdraw': destructive,
     'session.entry': read,
+    'release_notes.presented': repeatableWrite,
+    'release_notes.show': read,
     'session.set_decision': repeatableWrite,
     'session.decline_update': repeatableWrite,
     'session.answer_shadow_notice': repeatableWrite,
@@ -104,6 +107,15 @@ export const toolAnnotations = {
     'project.update': write,
     'work_item.list': read,
     'work_item.statuses': read,
+    'work_item.workflow': read,
+    'work_item.configure_workflow': write,
+    'work_item.setup_workflow': write,
+    'work_item.describe_status': write,
+    'work_item.update_status': write,
+    'work_item.create_status': write,
+    'work_item.archive_status': write,
+    'work_item.restore_status': write,
+    'work_item.set_initial_status': write,
     'work_item.get': read,
     'project.clone': outward,
     'project.link': write,

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

@@ -1,3 +1,7 @@
+import { registerDeliveryTools } from './delivery-tools.js';
+import { registerStatusMeaningTools } from './status-meaning-tools.js';
+import { registerWorkflowTools } from './workflow-tools.js';
+import { registerReleaseTools } from './release-tools.js';
 import { ensureDecisionMode, registerDecisionTools } from './decision-tools.js';
 import * as z from 'zod/v4';
 import { validationIds } from '../runtime/bridge-service.js';
@@ -48,6 +52,8 @@ const checkpointBase = {
     idempotencyKey: z.string().uuid().optional(),
 };
 export const engineeringMemoryToolNames = [
+    'release_notes.presented',
+    'release_notes.show',
     'decision.mode',
     'decision.mode_status',
     'questionnaire.decide',
@@ -57,6 +63,7 @@ export const engineeringMemoryToolNames = [
     'worktree.set_policy',
     'worktree.list',
     'worktree.reconcile',
+    'worktree.prepare_files',
     'task.heartbeat',
     'task.pause',
     'worktree.release',
@@ -135,6 +142,15 @@ export const engineeringMemoryToolNames = [
     'work_item.confirm_plan',
     'project.update',
     'work_item.statuses',
+    'work_item.workflow',
+    'work_item.configure_workflow',
+    'work_item.setup_workflow',
+    'work_item.describe_status',
+    'work_item.update_status',
+    'work_item.create_status',
+    'work_item.archive_status',
+    'work_item.restore_status',
+    'work_item.set_initial_status',
     'work_item.list',
     'work_item.get',
     'project.clone',
@@ -195,7 +211,10 @@ const waiverCopy = {
     },
 };
 export function registerQuestionnaireTools(server, service) {
+    registerReleaseTools(server, service);
     registerDecisionTools(server, service);
+    registerWorkflowTools(server, service);
+    registerStatusMeaningTools(server, service);
     server.registerTool('questionnaire.answer_from_host', {
         description: 'Relay an actual answer from a host-permitted blocking native AskUserQuestion or request_user_input control to the exact durable question. First read hostFallback from the pending operation or questionnaire.resume with presentation host_native, display its unchanged question/options/notices and await the real native result. Never infer answers, use chat consent, asynchronous controls, defaults or a declined/dismissed form. The hostTool field is agent-reported provenance, not transport-verified attestation. Bind requestKey and contentHash exactly; changed scope, withdrawn questions, invalid or conflicting answers are refused. This only saves the answer; retry the owning operation for current authority and version checks.',
         inputSchema: hostAnswerSchema.extend({
@@ -751,13 +770,7 @@ export function registerEngineeringMemoryTools(server, service) {
         }
         return toolResult(await service.taskVerify(request));
     });
-    server.registerTool('task.close', {
-        description: 'Close a task only when backend verification still matches the current Git diff hash.',
-        inputSchema: z.object({
-            repoRoot: optionalRepoRoot,
-            taskId: z.string().min(1),
-        }),
-    }, async (input) => toolResult(await service.taskClose(input)));
+    registerDeliveryTools(server, service);
     server.registerTool('task.abandon', {
         description: "Abandon a task the user has said they are giving up on, so it stops holding its proposals and its local pointer. It has no effect on any other task: nobody else's work waits on this, and nothing already verified or closed is undone. Ask the user first; never abandon a task on your own judgement.",
         inputSchema: z.object({
@@ -1038,6 +1051,134 @@ export function registerEngineeringMemoryTools(server, service) {
             includeArchived: z.boolean().optional(),
         }),
     }, async (input) => toolResult(await service.workItemStatuses(input)));
+    server.registerTool('work_item.workflow', {
+        description: 'Read a coherent page of project stages and the six stored lifecycle event rules without seeding or changing anything. Pass the returned snapshot on every later page; a conflict requires rereading from the start. Page through all statuses before reviewing workflow choices. Every event target includes its human definition or null with targetUnavailable for a missing/foreign target; archived targets are unavailable. Do not infer meanings from names or show snapshot hashes as user choices.',
+        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(),
+            snapshot: z
+                .string()
+                .regex(/^[a-f0-9]{64}$/)
+                .optional(),
+        })
+            .strict(),
+    }, async (input) => toolResult(await service.workItemWorkflow(input)));
+    server.registerTool('work_item.configure_workflow', {
+        description: 'Apply explicit project workflow choices together against the complete snapshot from work_item.workflow. Requires current owner, maintainer or organization administration. Supply each of work_started, pr_opened, all_prs_merged, test_failed and blocked_declared exactly once, with an active same-project target and explicit automatic/confirm/ignore mode. The blocked target becomes the active parked stage. Optional draft_pr_opened preserves its stored rule when omitted; a missing draft rule starts automatic with no target. Only draft may have a null target. Existing work and the initial stage stay unchanged; no event fires. Resolve choices under the task decision mode, use human stage names, and never silently substitute a newer snapshot after conflict.',
+        inputSchema: z
+            .object({
+            projectId: z.string().uuid(),
+            expectedSnapshot: z.string().regex(/^[a-f0-9]{64}$/),
+            rules: z
+                .array(z
+                .object({
+                event: z.enum([
+                    'work_started',
+                    'draft_pr_opened',
+                    'pr_opened',
+                    'all_prs_merged',
+                    'test_failed',
+                    'blocked_declared',
+                ]),
+                toStatusId: z.string().uuid().nullable(),
+                mode: z.enum(['automatic', 'confirm', 'ignore']),
+            })
+                .strict())
+                .min(5)
+                .max(6)
+                .refine((rules) => new Set(rules.map((rule) => rule.event)).size === rules.length, {
+                message: 'Each event may be supplied only once.',
+            }),
+        })
+            .strict(),
+    }, async (input) => toolResult(await service.workItemConfigureWorkflow(input)));
+    server.registerTool('work_item.create_status', {
+        description: 'Create one project status definition with an explicit stable slug, name, category and position. Requires current owner, maintainer or organization administration. Read work_item.statuses including archives first; a duplicate slug is refused, never silently renamed or restored. Meanings and entry conditions come from the project user. New definitions are not initial or parked; omitted actionable/terminal flags are false. This does not move work or configure events.',
+        inputSchema: z
+            .object({
+            projectId: z.string().uuid(),
+            slug: z
+                .string()
+                .trim()
+                .min(1)
+                .max(64)
+                .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+            name: z
+                .string()
+                .trim()
+                .min(1)
+                .max(120)
+                .regex(/^[^\r\n]+$/),
+            category: z.enum(['new', 'indeterminate', 'done']),
+            position: z.number().int().min(0).max(2_147_483_647),
+            meaning: z.string().trim().max(4000).optional(),
+            entryRule: z.string().trim().max(4000).optional(),
+            isActionable: z.boolean().optional(),
+            isTerminal: z.boolean().optional(),
+        })
+            .strict(),
+    }, async (input) => toolResult(await service.workItemCreateStatus(input)));
+    server.registerTool('work_item.archive_status', {
+        description: 'Archive a non-initial project status at its current lockVersion from work_item.statuses. Existing items stay in that column; its metadata and event targets remain unchanged. Current owner, maintainer or organization administration required. Initial definitions need separate role setup and are refused here. Never silently retry a stale version.',
+        inputSchema: z
+            .object({
+            projectId: z.string().uuid(),
+            statusId: z.string().uuid(),
+            expectedVersion: z.number().int().min(1).max(2_147_483_647),
+        })
+            .strict(),
+    }, async (input) => toolResult(await service.workItemSetStatusArchived({ ...input, archived: true })));
+    server.registerTool('work_item.restore_status', {
+        description: 'Restore a non-initial project status at its current lockVersion from work_item.statuses with includeArchived:true. Existing work and metadata stay intact. Current owner, maintainer or organization administration required. Restoring an initial definition requires separate role setup and is refused here. Never silently retry a stale version.',
+        inputSchema: z
+            .object({
+            projectId: z.string().uuid(),
+            statusId: z.string().uuid(),
+            expectedVersion: z.number().int().min(1).max(2_147_483_647),
+        })
+            .strict(),
+    }, async (input) => toolResult(await service.workItemSetStatusArchived({ ...input, archived: false })));
+    server.registerTool('work_item.set_initial_status', {
+        description: 'Choose the active project stage where newly created work starts. Read all pages of work_item.statuses first. Pass the target lockVersion and the observed active initial status id and lockVersion, or explicit null for both prior-initial fields when none exists. Requires current owner, maintainer or organization administration. Existing work, stage meanings and event targets stay unchanged; this is separate from work_started. A stale selection returns a conflict; reread instead of silently retrying.',
+        inputSchema: z
+            .object({
+            projectId: z.string().uuid(),
+            statusId: z.string().uuid(),
+            expectedVersion: z.number().int().min(1).max(2_147_483_647),
+            expectedInitialStatusId: z.string().uuid().nullable(),
+            expectedInitialVersion: z.number().int().min(1).max(2_147_483_647).nullable(),
+        })
+            .strict()
+            .refine((input) => (input.expectedInitialStatusId === null) === (input.expectedInitialVersion === null), {
+            message: 'The prior initial status and its version must both be present or both null.',
+        }),
+    }, async (input) => toolResult(await service.workItemSetInitialStatus(input)));
+    server.registerTool('work_item.update_status', {
+        description: 'Edit one active project status definition at its current lockVersion from work_item.statuses. Only project owners, maintainers and organization administrators may edit. Use meanings and entry conditions supplied by the project user; never invent them from a name. Omitted fields stay unchanged and empty text clears a meaning or entry condition. Show human status names when reviewing changes. This never moves work items, changes the stable slug, configures event roles or fires an event. Creation, archival and role setup are not part of this tool.',
+        inputSchema: z
+            .object({
+            projectId: z.string().uuid(),
+            statusId: z.string().uuid(),
+            expectedVersion: z.number().int().min(1).max(2_147_483_647),
+            name: z
+                .string()
+                .trim()
+                .min(1)
+                .max(120)
+                .regex(/^[^\r\n]+$/)
+                .optional(),
+            category: z.enum(['new', 'indeterminate', 'done']).optional(),
+            meaning: z.string().trim().max(4000).optional(),
+            entryRule: z.string().trim().max(4000).optional(),
+            position: z.number().int().min(0).max(2_147_483_647).optional(),
+            isActionable: z.boolean().optional(),
+            isTerminal: z.boolean().optional(),
+        })
+            .strict(),
+    }, async (input) => toolResult(await service.workItemUpdateStatus(input)));
     server.registerTool('work_item.list', {
         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({