@aopslabs/aops 0.3.24 → 0.3.26

package/dist/commands/pm/projectman.js

@@ -2701,6 +2701,283 @@ export async function runPmTaskCreate(options = {}) {
         process.exitCode = 1;
     }
 }
+function readBoardColumnList(payload) {
+    if (Array.isArray(payload))
+        return payload.filter(isRecord);
+    if (!isRecord(payload))
+        return [];
+    return toRecordArray(unwrapHostedToolResult(payload));
+}
+function readRecordEnvelope(payload) {
+    if (!isRecord(payload))
+        return {};
+    const unwrapped = unwrapHostedToolResult(payload);
+    if (!isRecord(unwrapped))
+        return {};
+    const inner = unwrapped.data;
+    return isRecord(inner) ? inner : unwrapped;
+}
+async function loadBoardColumns(execution, options, boardId) {
+    const listed = await invokeProjectmanTool(execution, options, {
+        toolId: 'projectman.kanban-board-column.list',
+        input: buildOwnerScopedInput(execution.resolvedContext, { board: boardId }),
+    });
+    const placements = readBoardColumnList(listed);
+    if (placements.length === 0)
+        return [];
+    const columnsPayload = await invokeProjectmanTool(execution, options, {
+        toolId: 'projectman.kanban-column.list',
+        input: buildOwnerScopedInput(execution.resolvedContext, {}),
+    });
+    const columns = readBoardColumnList(columnsPayload);
+    const byId = new Map(columns.map((column) => [normalizeNonEmpty(column.id) ?? '', column]));
+    const joined = placements.map((placement) => ({
+        ...placement,
+        column: byId.get(normalizeNonEmpty(placement.columnId) ?? '') ?? placement.column ?? null,
+    }));
+    return joined.sort((left, right) => Number(left.position ?? 0) - Number(right.position ?? 0));
+}
+function findBoardColumnPlacement(placements, selector) {
+    const wanted = selector.trim().toLowerCase();
+    if (!wanted)
+        return undefined;
+    return placements.find((entry) => {
+        const column = (entry?.column ?? {});
+        return [entry?.id, column?.id, column?.slug, column?.name]
+            .map((value) => (normalizeNonEmpty(value) ?? '').toLowerCase())
+            .includes(wanted);
+    });
+}
+export async function runPmColumnList(options = {}) {
+    try {
+        const boardValue = normalizeNonEmpty(options.board);
+        if (!boardValue)
+            throw new Error('Missing required --board.');
+        const execution = await prepareExecution(options);
+        if (!execution)
+            return;
+        const board = await resolveBoardRecord(execution, options, boardValue);
+        const boardId = normalizeNonEmpty(board.id);
+        const columns = await loadBoardColumns(execution, options, boardId ?? '');
+        emitFlowCommandResult(options, {
+            command: 'pm.column.list',
+            toolId: 'projectman.kanban-board-column.list',
+            surface: '/api/agent/tools',
+            resolvedContext: buildResolvedContextEnvelope(execution.resolvedContext),
+            input: { board: boardId },
+            result: { ok: true, data: columns, count: columns.length },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logError(`Failed to execute pm column list: ${augmentInvokeErrorMessage('projectman.kanban-board-column.list', message)}`);
+        process.exitCode = 1;
+    }
+}
+export async function runPmColumnAdd(options = {}) {
+    try {
+        ensureWriteFlags('create', options);
+        const boardValue = normalizeNonEmpty(options.board);
+        const name = normalizeNonEmpty(options.name);
+        if (!boardValue)
+            throw new Error('Missing required --board.');
+        if (!name)
+            throw new Error('Missing required --name.');
+        const wipLimit = parseOptionalInteger(options.wipLimit, '--wip-limit');
+        const previewPosition = parseOptionalInteger(options.position, '--position');
+        const execution = await prepareExecution(options);
+        if (!execution)
+            return;
+        const board = await resolveBoardRecord(execution, options, boardValue);
+        const boardId = normalizeNonEmpty(board.id);
+        if (options.preview === true) {
+            const result = compactPayload({
+                ok: true,
+                preview: true,
+                action: 'add-board-column',
+                board: compactPayload({ id: boardId, name: normalizeNonEmpty(board.name) }),
+                column: compactPayload({
+                    name,
+                    slug: normalizeNonEmpty(options.slug),
+                    description: normalizeNonEmpty(options.description),
+                    wipLimit,
+                }),
+                placement: compactPayload({ board: boardId, position: previewPosition }),
+                writes: ['projectman.kanban-column.create', 'projectman.kanban-board-column.create'],
+                notes: [
+                    'Two hosted writes run in order; the placement carries the id the column create returns.',
+                    'If the placement fails the column is deleted again, so a failed run leaves nothing behind.',
+                ],
+            });
+            emitFlowCommandResult(options, {
+                command: 'pm.column.add',
+                toolId: 'projectman.kanban-board-column.create',
+                surface: '/api/agent/tools',
+                resolvedContext: buildResolvedContextEnvelope(execution.resolvedContext),
+                input: { board: boardId, name },
+                result,
+            });
+            return;
+        }
+        const created = await invokeProjectmanTool(execution, options, {
+            toolId: 'projectman.kanban-column.create',
+            input: buildOwnerScopedInput(execution.resolvedContext, compactPayload({
+                name,
+                slug: normalizeNonEmpty(options.slug),
+                description: normalizeNonEmpty(options.description),
+                wipLimit: parseOptionalInteger(options.wipLimit, '--wip-limit'),
+            })),
+        });
+        const columnRecord = readRecordEnvelope(created);
+        const columnId = normalizeNonEmpty(columnRecord.id);
+        if (!columnId)
+            throw new Error('Column was created but no id was returned.');
+        let placement;
+        try {
+            placement = await invokeProjectmanTool(execution, options, {
+                toolId: 'projectman.kanban-board-column.create',
+                input: buildOwnerScopedInput(execution.resolvedContext, compactPayload({
+                    board: boardId,
+                    column: columnId,
+                    position: previewPosition,
+                })),
+            });
+        }
+        catch (placementError) {
+            const reason = placementError instanceof Error ? placementError.message : String(placementError);
+            try {
+                await invokeProjectmanTool(execution, options, {
+                    toolId: 'projectman.kanban-column.delete',
+                    input: buildOwnerScopedInput(execution.resolvedContext, { id: columnId }),
+                });
+                throw new Error(`Placing the column on the board failed, so the column was removed again: ${reason}`);
+            }
+            catch (cleanupError) {
+                const cleanupReason = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+                if (cleanupReason.startsWith('Placing the column on the board failed'))
+                    throw cleanupError;
+                throw new Error(`Placing the column on the board failed (${reason}) and removing the orphaned column ${columnId} also failed (${cleanupReason}); delete it manually.`);
+            }
+        }
+        emitFlowCommandResult(options, {
+            command: 'pm.column.add',
+            toolId: 'projectman.kanban-board-column.create',
+            surface: '/api/agent/tools',
+            resolvedContext: buildResolvedContextEnvelope(execution.resolvedContext),
+            input: { board: boardId, name },
+            result: { ok: true, data: { column: columnRecord, placement: readRecordEnvelope(placement) } },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logError(`Failed to execute pm column add: ${augmentInvokeErrorMessage('projectman.kanban-board-column.create', message)}`);
+        process.exitCode = 1;
+    }
+}
+export async function runPmColumnRemove(options = {}) {
+    try {
+        ensureWriteFlags('delete', options);
+        const boardValue = normalizeNonEmpty(options.board);
+        const columnValue = normalizeNonEmpty(options.column);
+        if (!boardValue)
+            throw new Error('Missing required --board.');
+        if (!columnValue)
+            throw new Error('Missing required --column.');
+        const execution = await prepareExecution(options);
+        if (!execution)
+            return;
+        const board = await resolveBoardRecord(execution, options, boardValue);
+        const boardId = normalizeNonEmpty(board.id);
+        const placements = await loadBoardColumns(execution, options, boardId ?? '');
+        const placement = findBoardColumnPlacement(placements, columnValue);
+        if (!placement)
+            throw new Error(`Column "${columnValue}" is not on board "${boardValue}".`);
+        const placementId = normalizeNonEmpty(placement.id);
+        const taskPayload = await invokeProjectmanReadTool(execution, options, {
+            toolId: 'projectman.kanban-task.list',
+            input: buildOwnerScopedInput(execution.resolvedContext, { board: boardId }),
+        });
+        const tasks = readBoardColumnList(taskPayload);
+        const occupants = tasks.filter((task) => normalizeNonEmpty(task.boardColumnId) === placementId);
+        if (occupants.length > 0) {
+            const codes = occupants.map((task) => normalizeNonEmpty(task.taskCode) ?? normalizeNonEmpty(task.id) ?? '?').join(', ');
+            throw new Error(`Column "${columnValue}" still holds ${occupants.length} task(s) (${codes}); move them to another column first.`);
+        }
+        const payload = await invokeProjectmanTool(execution, options, {
+            toolId: 'projectman.kanban-board-column.delete',
+            input: buildOwnerScopedInput(execution.resolvedContext, { id: placementId }),
+        });
+        emitFlowCommandResult(options, {
+            command: 'pm.column.remove',
+            toolId: 'projectman.kanban-board-column.delete',
+            surface: '/api/agent/tools',
+            resolvedContext: buildResolvedContextEnvelope(execution.resolvedContext),
+            input: { board: boardId, id: placementId },
+            result: { ok: true, data: payload },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logError(`Failed to execute pm column remove: ${augmentInvokeErrorMessage('projectman.kanban-board-column.delete', message)}`);
+        process.exitCode = 1;
+    }
+}
+export async function runPmColumnReorder(options = {}) {
+    try {
+        ensureWriteFlags('update', options);
+        const boardValue = normalizeNonEmpty(options.board);
+        const order = normalizeArrayValues(options.order) ?? [];
+        if (!boardValue)
+            throw new Error('Missing required --board.');
+        if (order.length === 0)
+            throw new Error('Missing required --order (repeat it once per column, in the wanted order).');
+        const execution = await prepareExecution(options);
+        if (!execution)
+            return;
+        const board = await resolveBoardRecord(execution, options, boardValue);
+        const boardId = normalizeNonEmpty(board.id);
+        const placements = await loadBoardColumns(execution, options, boardId ?? '');
+        const orderedIds = order.map((value) => {
+            const placement = findBoardColumnPlacement(placements, value);
+            if (!placement)
+                throw new Error(`Column "${value}" is not on board "${boardValue}".`);
+            return normalizeNonEmpty(placement.id);
+        });
+        const seen = new Set();
+        for (let index = 0; index < orderedIds.length; index += 1) {
+            const id = orderedIds[index] ?? '';
+            if (seen.has(id)) {
+                throw new Error(`--order names the same column twice ("${order[index]}"); name every column exactly once.`);
+            }
+            seen.add(id);
+        }
+        const missing = placements
+            .map((placement) => normalizeNonEmpty(placement.id) ?? '')
+            .filter((id) => !seen.has(id));
+        if (missing.length > 0 || orderedIds.length !== placements.length) {
+            throw new Error(`--order must name every column on the board exactly once (${placements.length}); received ${orderedIds.length}` +
+                (missing.length > 0 ? `, missing ${missing.length}` : '') +
+                '.');
+        }
+        const payload = await invokeProjectmanTool(execution, options, {
+            toolId: 'projectman.kanban-board-column.reorder',
+            input: buildOwnerScopedInput(execution.resolvedContext, { board: boardId, orderedIds }),
+        });
+        emitFlowCommandResult(options, {
+            command: 'pm.column.reorder',
+            toolId: 'projectman.kanban-board-column.reorder',
+            surface: '/api/agent/tools',
+            resolvedContext: buildResolvedContextEnvelope(execution.resolvedContext),
+            input: { board: boardId, orderedIds },
+            result: { ok: true, data: payload },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logError(`Failed to execute pm column reorder: ${augmentInvokeErrorMessage('projectman.kanban-board-column.reorder', message)}`);
+        process.exitCode = 1;
+    }
+}
 export async function runPmBoardCreate(options = {}) {
     try {
         ensureWriteFlags('create', options);
@@ -3833,8 +4110,6 @@ export async function runPmSprintCreate(options = {}) {
         const task = normalizeNonEmpty(options.task);
         const name = normalizeNonEmpty(options.name);
         const goal = normalizeNonEmpty(options.goal);
-        if (!task)
-            throw new Error('Missing required --task.');
         if (!name)
             throw new Error('Missing required --name.');
         if (!goal)
@@ -3842,11 +4117,11 @@ export async function runPmSprintCreate(options = {}) {
         const execution = await prepareExecution(options);
         if (!execution)
             return;
-        const input = buildOwnerScopedInput(execution.resolvedContext, {
+        const input = buildOwnerScopedInput(execution.resolvedContext, compactPayload({
             kanbanTask: task,
             name,
             goal,
-        });
+        }));
         const references = normalizeArrayValues(options.reference);
         const scope = normalizeArrayValues(options.scopeItem);
         const validationPlan = normalizeArrayValues(options.validationItem);
@@ -4533,8 +4808,6 @@ export async function runPmPlanCreate(options = {}) {
         const task = normalizeNonEmpty(options.task);
         const name = normalizeNonEmpty(options.name);
         const goal = normalizeNonEmpty(options.goal);
-        if (!task)
-            throw new Error('Missing required --task.');
         if (!name)
             throw new Error('Missing required --name.');
         if (!goal)
@@ -4542,11 +4815,11 @@ export async function runPmPlanCreate(options = {}) {
         const execution = await prepareExecution(options);
         if (!execution)
             return;
-        const input = buildOwnerScopedInput(execution.resolvedContext, {
+        const input = buildOwnerScopedInput(execution.resolvedContext, compactPayload({
             kanbanTask: task,
             name,
             goal,
-        });
+        }));
         const references = normalizeArrayValues(options.reference);
         const scope = normalizeArrayValues(options.scopeItem);
         const validationPlan = normalizeArrayValues(options.validationItem);

package/dist/commands/start-disciplines.js

@@ -86,10 +86,10 @@ export const START_GUARDRAIL_REGISTRY = [
     {
         id: 'assignment-via-canonical-refs',
         title: 'Assignment via canonical refs',
-        description: 'Assignments carry mission/ktask/plan refs; chat prose alone is not an assignment.',
+        description: 'Assignments carry ktask/plan refs; chat prose alone is not an assignment.',
         disciplines: ['coordinator-loop'],
         phase: 'execution',
-        evidence: ['agentspace.mission', 'projectman.kanban-task', 'projectman.sprint'],
+        evidence: ['projectman.kanban-task', 'projectman.sprint'],
         enforcementLevel: 'advisory',
     },
     {
@@ -230,28 +230,19 @@ export const START_GUARDRAIL_REGISTRY = [
     {
         id: 'closeout-triage-open-issues',
         title: 'Closeout triages open issues',
-        description: 'Open issues are resolved, linked to follow-up work, or explicitly deferred with an owner according to the mission policy.',
+        description: 'Open issues are resolved, linked to follow-up work, or explicitly deferred with an owner according to the discipline policy.',
         disciplines: ['solo-pm-loop', 'build-review-chat', 'design-first-consensus', 'coordinator-loop'],
         phase: 'closeout',
         evidence: ['projectman.issue'],
         enforcementLevel: 'soft-preflight',
     },
-    {
-        id: 'closeout-mission-status-finalized',
-        title: 'Closeout finalizes mission status',
-        description: 'The mission is left in a truthful status such as handoff or completed instead of a stale active state.',
-        disciplines: ['solo-pm-loop', 'build-review-chat', 'design-first-consensus', 'coordinator-loop'],
-        phase: 'closeout',
-        evidence: ['agentspace.mission.status'],
-        enforcementLevel: 'soft-preflight',
-    },
     {
         id: 'closeout-resume-readiness',
         title: 'Closeout proves resume readiness',
-        description: 'The mission resume pack has enough objective, policy, plan, memory, review, issue, and next-action context for the next session.',
+        description: 'The resume surfaces carry enough objective, plan, memory, review, issue, and next-action context for the next session.',
         disciplines: ['solo-pm-loop', 'build-review-chat', 'design-first-consensus', 'coordinator-loop'],
         phase: 'closeout',
-        evidence: ['agentspace.mission.resume-pack'],
+        evidence: ['agentspace.memory', 'projectman.implementation-plan', 'projectman.handoff'],
         enforcementLevel: 'soft-preflight',
     },
     {
@@ -284,10 +275,10 @@ export const START_GUARDRAIL_REGISTRY = [
     {
         id: 'closeout-assignment-queue-truthful',
         title: 'Closeout leaves the assignment queue truthful',
-        description: 'Coordinator closeout binds every operator request to mission/ktask/plan records, marks it completed, or defers it explicitly with an owner.',
+        description: 'Coordinator closeout binds every operator request to ktask/plan records, marks it completed, or defers it explicitly with an owner.',
         disciplines: ['coordinator-loop'],
         phase: 'closeout',
-        evidence: ['agentspace.mission', 'projectman.kanban-task'],
+        evidence: ['projectman.kanban-task'],
         enforcementLevel: 'soft-preflight',
     },
     {
@@ -343,7 +334,6 @@ export const START_DISCIPLINE_PROFILES = {
             'closeout-handoff-memory',
             'closeout-triage-open-reviews',
             'closeout-triage-open-issues',
-            'closeout-mission-status-finalized',
             'closeout-resume-readiness',
             'closeout-session-summary',
         ],
@@ -388,7 +378,6 @@ export const START_DISCIPLINE_PROFILES = {
             'closeout-handoff-memory',
             'closeout-triage-open-reviews',
             'closeout-triage-open-issues',
-            'closeout-mission-status-finalized',
             'closeout-resume-readiness',
             'closeout-session-summary',
             'closeout-slice-review-accounted',
@@ -433,7 +422,6 @@ export const START_DISCIPLINE_PROFILES = {
             'closeout-handoff-memory',
             'closeout-triage-open-reviews',
             'closeout-triage-open-issues',
-            'closeout-mission-status-finalized',
             'closeout-resume-readiness',
             'closeout-session-summary',
             'closeout-discuss-output-finalized',
@@ -451,7 +439,7 @@ export const START_DISCIPLINE_PROFILES = {
         ],
         plan: {
             owner: 'projectman',
-            rhythm: 'operator request -> coordinator research -> mission/ktask/plan authoring -> chat assignment with canonical refs -> per-slice RR -> instructed pathspec commit',
+            rhythm: 'operator request -> coordinator research -> ktask/plan authoring -> chat assignment with canonical refs -> per-slice RR -> instructed pathspec commit',
         },
         review: {
             owner: 'projectman.review-request',
@@ -487,7 +475,6 @@ export const START_DISCIPLINE_PROFILES = {
             'closeout-handoff-memory',
             'closeout-triage-open-reviews',
             'closeout-triage-open-issues',
-            'closeout-mission-status-finalized',
             'closeout-resume-readiness',
             'closeout-session-summary',
             'closeout-slice-review-accounted',