chore: consolidate new foundation and archive v1 (#1495)
This commit is contained in:
@@ -0,0 +1,38 @@
|
||||
{
|
||||
"name": "@mosaicstack/coord",
|
||||
"version": "0.0.2",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://git.mosaicstack.dev/mosaicstack/stack.git",
|
||||
"directory": "packages/coord"
|
||||
},
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"exports": {
|
||||
".": {
|
||||
"types": "./dist/index.d.ts",
|
||||
"default": "./dist/index.js"
|
||||
}
|
||||
},
|
||||
"scripts": {
|
||||
"build": "tsc",
|
||||
"lint": "eslint src",
|
||||
"typecheck": "tsc --noEmit",
|
||||
"test": "vitest run --passWithNoTests"
|
||||
},
|
||||
"dependencies": {
|
||||
"@mosaicstack/types": "workspace:*"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.0.0",
|
||||
"typescript": "^5.8.0",
|
||||
"vitest": "^2.0.0"
|
||||
},
|
||||
"publishConfig": {
|
||||
"registry": "https://git.mosaicstack.dev/api/packages/mosaicstack/npm/",
|
||||
"access": "public"
|
||||
},
|
||||
"files": [
|
||||
"dist"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
import {
|
||||
InMemoryInteractionCoordinationPort,
|
||||
InteractionCoordinationClient,
|
||||
type CoordinationScope,
|
||||
type InteractionCoordinationAuthorityError,
|
||||
type InteractionCoordinationPort,
|
||||
} from '../index.js';
|
||||
|
||||
const scope: CoordinationScope = {
|
||||
actorId: 'operator-1',
|
||||
tenantId: 'tenant-a',
|
||||
correlationId: 'corr-1',
|
||||
requesterAgentId: 'Nova',
|
||||
};
|
||||
|
||||
function client(
|
||||
port: InteractionCoordinationPort,
|
||||
handoffIdFactory: () => string = (): string => 'handoff-1',
|
||||
): InteractionCoordinationClient {
|
||||
return new InteractionCoordinationClient(
|
||||
{ interactionAgentId: 'Nova', orchestrationAgentId: 'Conductor' },
|
||||
port,
|
||||
handoffIdFactory,
|
||||
);
|
||||
}
|
||||
|
||||
describe('InteractionCoordinationClient', (): void => {
|
||||
it('round-trips handoff, observation, and result through the native port with identities as data', async (): Promise<void> => {
|
||||
const adapter = new InMemoryInteractionCoordinationPort();
|
||||
const coordination = client(adapter);
|
||||
|
||||
await expect(
|
||||
coordination.handoff(
|
||||
{ idempotencyKey: 'handoff-request-1', summary: 'Implement the requested feature' },
|
||||
scope,
|
||||
),
|
||||
).resolves.toEqual({
|
||||
handoffId: 'handoff-1',
|
||||
targetAgentId: 'Conductor',
|
||||
status: 'queued',
|
||||
correlationId: 'corr-1',
|
||||
});
|
||||
|
||||
adapter.recordActivity('handoff-1', 'running', 'Orchestrator accepted the request');
|
||||
adapter.recordResult('handoff-1', 'completed', 'Merged by orchestrator');
|
||||
|
||||
await expect(coordination.observe('handoff-1', scope)).resolves.toMatchObject({
|
||||
status: 'completed',
|
||||
targetAgentId: 'Conductor',
|
||||
activity: expect.arrayContaining([
|
||||
expect.objectContaining({ status: 'queued' }),
|
||||
expect.objectContaining({ status: 'running' }),
|
||||
expect.objectContaining({ status: 'completed' }),
|
||||
]),
|
||||
});
|
||||
await expect(coordination.result('handoff-1', scope)).resolves.toEqual({
|
||||
handoffId: 'handoff-1',
|
||||
targetAgentId: 'Conductor',
|
||||
status: 'completed',
|
||||
correlationId: 'corr-1',
|
||||
summary: 'Merged by orchestrator',
|
||||
});
|
||||
|
||||
expect(coordination).not.toHaveProperty('dispatch');
|
||||
expect(coordination).not.toHaveProperty('assign');
|
||||
expect(coordination).not.toHaveProperty('review');
|
||||
expect(coordination).not.toHaveProperty('merge');
|
||||
expect(coordination).not.toHaveProperty('cancel');
|
||||
});
|
||||
|
||||
it('fails closed before delivery when an unconfigured agent requests orchestrator work', async (): Promise<void> => {
|
||||
const adapter = new InMemoryInteractionCoordinationPort();
|
||||
|
||||
await expect(
|
||||
client(adapter).handoff(
|
||||
{ idempotencyKey: 'handoff-request-1', summary: 'Implement the requested feature' },
|
||||
{ ...scope, requesterAgentId: 'Untrusted' },
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
code: 'requester_forbidden',
|
||||
} satisfies Partial<InteractionCoordinationAuthorityError>);
|
||||
});
|
||||
|
||||
it('rejects self-delegation configuration before constructing a client', (): void => {
|
||||
expect(
|
||||
(): InteractionCoordinationClient =>
|
||||
new InteractionCoordinationClient(
|
||||
{ interactionAgentId: 'Nova', orchestrationAgentId: 'Nova' },
|
||||
new InMemoryInteractionCoordinationPort(),
|
||||
),
|
||||
).toThrow('Interaction and orchestration identities must differ');
|
||||
});
|
||||
|
||||
it('rejects whitespace-equivalent self-delegation identities', (): void => {
|
||||
expect(
|
||||
(): InteractionCoordinationClient =>
|
||||
new InteractionCoordinationClient(
|
||||
{ interactionAgentId: 'Nova ', orchestrationAgentId: 'Nova' },
|
||||
new InMemoryInteractionCoordinationPort(),
|
||||
),
|
||||
).toThrow('Interaction and orchestration identities must differ');
|
||||
});
|
||||
|
||||
it('does not expose another tenant handoff to observe or result', async (): Promise<void> => {
|
||||
const adapter = new InMemoryInteractionCoordinationPort();
|
||||
const coordination = client(adapter);
|
||||
await coordination.handoff(
|
||||
{ idempotencyKey: 'handoff-request-1', summary: 'Implement the requested feature' },
|
||||
scope,
|
||||
);
|
||||
|
||||
const otherTenantScope = { ...scope, tenantId: 'tenant-b' };
|
||||
await expect(coordination.observe('handoff-1', otherTenantScope)).rejects.toMatchObject({
|
||||
code: 'forbidden',
|
||||
});
|
||||
await expect(coordination.result('handoff-1', otherTenantScope)).rejects.toMatchObject({
|
||||
code: 'forbidden',
|
||||
});
|
||||
});
|
||||
|
||||
it('bounds native handoff retention by evicting the oldest handoff', async (): Promise<void> => {
|
||||
const adapter = new InMemoryInteractionCoordinationPort({ maxHandoffs: 1 });
|
||||
const first = client(adapter, (): string => 'handoff-1');
|
||||
const second = client(adapter, (): string => 'handoff-2');
|
||||
await first.handoff({ idempotencyKey: 'handoff-request-1', summary: 'First request' }, scope);
|
||||
await second.handoff({ idempotencyKey: 'handoff-request-2', summary: 'Second request' }, scope);
|
||||
|
||||
await expect(first.observe('handoff-1', scope)).rejects.toMatchObject({ code: 'not_found' });
|
||||
await expect(second.observe('handoff-2', scope)).resolves.toMatchObject({ status: 'queued' });
|
||||
});
|
||||
|
||||
it('fails closed when a transport reports target drift', async (): Promise<void> => {
|
||||
const adapter: InteractionCoordinationPort = {
|
||||
handoff: vi.fn(async () => ({
|
||||
handoffId: 'handoff-1',
|
||||
targetAgentId: 'Unexpected',
|
||||
status: 'accepted' as const,
|
||||
correlationId: 'corr-1',
|
||||
})),
|
||||
observe: vi.fn(),
|
||||
result: vi.fn(),
|
||||
};
|
||||
|
||||
await expect(
|
||||
client(adapter).handoff(
|
||||
{ idempotencyKey: 'handoff-request-1', summary: 'Implement the requested feature' },
|
||||
scope,
|
||||
),
|
||||
).rejects.toMatchObject({
|
||||
code: 'target_drift',
|
||||
} satisfies Partial<InteractionCoordinationAuthorityError>);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,41 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { resolveLaunchCommand } from '../runner.js';
|
||||
|
||||
describe('coord consequential-runtime launch gate', () => {
|
||||
it('routes default and direct configured Claude commands through mosaic', () => {
|
||||
expect(resolveLaunchCommand('claude', 'continue', undefined)).toEqual([
|
||||
'mosaic',
|
||||
'claude',
|
||||
'-p',
|
||||
'continue',
|
||||
]);
|
||||
expect(resolveLaunchCommand('claude', 'continue', ['claude', '-p', '{prompt}'])).toEqual([
|
||||
'mosaic',
|
||||
'claude',
|
||||
'-p',
|
||||
'continue',
|
||||
]);
|
||||
});
|
||||
|
||||
it('preserves an already-gated Claude command and rejects unknown launchers', () => {
|
||||
expect(
|
||||
resolveLaunchCommand('claude', 'continue', ['mosaic', 'yolo', 'claude', '{prompt}']),
|
||||
).toEqual(['mosaic', 'yolo', 'claude', 'continue']);
|
||||
expect(() => resolveLaunchCommand('claude', 'continue', ['custom-launcher'])).toThrow(
|
||||
/must use `mosaic claude`/,
|
||||
);
|
||||
});
|
||||
|
||||
it('does not change the out-of-scope Codex command contract', () => {
|
||||
expect(resolveLaunchCommand('codex', 'continue', undefined)).toEqual([
|
||||
'codex',
|
||||
'-p',
|
||||
'continue',
|
||||
]);
|
||||
expect(resolveLaunchCommand('codex', 'continue', ['codex', '{prompt}'])).toEqual([
|
||||
'codex',
|
||||
'continue',
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,102 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { parseTasksFile, writeTasksFile } from '../tasks-file.js';
|
||||
import type { MissionTask } from '../types.js';
|
||||
|
||||
const SAMPLE_TASKS_MD = `# Tasks — MVP
|
||||
|
||||
> Single-writer: orchestrator only. Workers read but never modify.
|
||||
|
||||
| id | status | milestone | description | pr | notes |
|
||||
| ------ | ----------- | --------- | ------------------------------------------ | --- | ----- |
|
||||
| P0-001 | done | Phase 0 | Scaffold monorepo | #60 | #1 |
|
||||
| P0-002 | done | Phase 0 | @mosaicstack/types — migrate and extend | #65 | #2 |
|
||||
| P1-001 | in-progress | Phase 1 | apps/gateway scaffold | #61 | #10 |
|
||||
| P2-001 | not-started | Phase 2 | @mosaicstack/agent — Pi SDK integration | — | #19 |
|
||||
| P2-002 | blocked | Phase 2 | Multi-provider support | — | #20 |
|
||||
`;
|
||||
|
||||
describe('parseTasksFile', () => {
|
||||
it('parses a valid TASKS.md into MissionTask[]', () => {
|
||||
const tasks = parseTasksFile(SAMPLE_TASKS_MD);
|
||||
expect(tasks).toHaveLength(5);
|
||||
});
|
||||
|
||||
it('extracts task IDs correctly', () => {
|
||||
const tasks = parseTasksFile(SAMPLE_TASKS_MD);
|
||||
expect(tasks.map((t) => t.id)).toEqual(['P0-001', 'P0-002', 'P1-001', 'P2-001', 'P2-002']);
|
||||
});
|
||||
|
||||
it('extracts statuses correctly', () => {
|
||||
const tasks = parseTasksFile(SAMPLE_TASKS_MD);
|
||||
expect(tasks.map((t) => t.status)).toEqual([
|
||||
'done',
|
||||
'done',
|
||||
'in-progress',
|
||||
'not-started',
|
||||
'blocked',
|
||||
]);
|
||||
});
|
||||
|
||||
it('extracts milestones correctly', () => {
|
||||
const tasks = parseTasksFile(SAMPLE_TASKS_MD);
|
||||
expect(tasks[0]!.milestone).toBe('Phase 0');
|
||||
expect(tasks[2]!.milestone).toBe('Phase 1');
|
||||
expect(tasks[3]!.milestone).toBe('Phase 2');
|
||||
});
|
||||
|
||||
it('extracts PR references', () => {
|
||||
const tasks = parseTasksFile(SAMPLE_TASKS_MD);
|
||||
expect(tasks[0]!.pr).toBe('#60');
|
||||
expect(tasks[3]!.pr).toBe('—');
|
||||
});
|
||||
|
||||
it('returns empty array for empty content', () => {
|
||||
expect(parseTasksFile('')).toEqual([]);
|
||||
expect(parseTasksFile('# No table here')).toEqual([]);
|
||||
});
|
||||
|
||||
it('handles legacy status values', () => {
|
||||
const content = `| id | status | description |
|
||||
|----|--------|-------------|
|
||||
| T1 | completed | Task one |
|
||||
| T2 | pending | Task two |
|
||||
| T3 | failed | Task three |
|
||||
`;
|
||||
const tasks = parseTasksFile(content);
|
||||
expect(tasks[0]!.status).toBe('done');
|
||||
expect(tasks[1]!.status).toBe('not-started');
|
||||
expect(tasks[2]!.status).toBe('blocked');
|
||||
});
|
||||
});
|
||||
|
||||
describe('writeTasksFile', () => {
|
||||
it('generates valid markdown table', () => {
|
||||
const tasks: MissionTask[] = [
|
||||
{
|
||||
id: 'T-001',
|
||||
title: 'Test task',
|
||||
status: 'done',
|
||||
dependencies: [],
|
||||
milestone: 'Phase 1',
|
||||
pr: '#42',
|
||||
notes: '#1',
|
||||
},
|
||||
];
|
||||
|
||||
const output = writeTasksFile(tasks);
|
||||
expect(output).toContain('| T-001 | done | Phase 1 | Test task | #42 | #1 |');
|
||||
expect(output).toContain('# Tasks');
|
||||
});
|
||||
|
||||
it('roundtrips parse/write', () => {
|
||||
const tasks = parseTasksFile(SAMPLE_TASKS_MD);
|
||||
const output = writeTasksFile(tasks);
|
||||
const reparsed = parseTasksFile(output);
|
||||
expect(reparsed).toHaveLength(tasks.length);
|
||||
for (let i = 0; i < tasks.length; i++) {
|
||||
expect(reparsed[i]!.id).toBe(tasks[i]!.id);
|
||||
expect(reparsed[i]!.status).toBe(tasks[i]!.status);
|
||||
expect(reparsed[i]!.title).toBe(tasks[i]!.title);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,208 @@
|
||||
import {
|
||||
type CoordinationObservation,
|
||||
type CoordinationResult,
|
||||
type CoordinationScope,
|
||||
type InteractionCoordinationActivity,
|
||||
type InteractionCoordinationPort,
|
||||
type Handoff,
|
||||
type HandoffReceipt,
|
||||
type HandoffStatus,
|
||||
} from './interaction-coordination.js';
|
||||
|
||||
const DEFAULT_HANDOFF_TTL_MS = 60 * 60 * 1_000;
|
||||
const DEFAULT_MAX_HANDOFFS = 1_000;
|
||||
|
||||
interface StoredHandoff {
|
||||
readonly handoff: Handoff;
|
||||
status: HandoffStatus;
|
||||
readonly activity: InteractionCoordinationActivity[];
|
||||
readonly expiresAt: number;
|
||||
result?: CoordinationResult;
|
||||
}
|
||||
|
||||
export interface InMemoryInteractionCoordinationPortOptions {
|
||||
now?: () => Date;
|
||||
handoffTtlMs?: number;
|
||||
maxHandoffs?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Native deterministic queue/port adapter for the coordination boundary.
|
||||
* It intentionally has no fleet/tmux dependency. A future deployment adapter
|
||||
* implements InteractionCoordinationPort without changing interaction-plane callers.
|
||||
*/
|
||||
export class InMemoryInteractionCoordinationPort implements InteractionCoordinationPort {
|
||||
private readonly handoffs = new Map<string, StoredHandoff>();
|
||||
private readonly now: () => Date;
|
||||
private readonly handoffTtlMs: number;
|
||||
private readonly maxHandoffs: number;
|
||||
|
||||
constructor(options: InMemoryInteractionCoordinationPortOptions = {}) {
|
||||
this.now = options.now ?? (() => new Date());
|
||||
this.handoffTtlMs = options.handoffTtlMs ?? DEFAULT_HANDOFF_TTL_MS;
|
||||
this.maxHandoffs = options.maxHandoffs ?? DEFAULT_MAX_HANDOFFS;
|
||||
}
|
||||
|
||||
async handoff(handoff: Handoff): Promise<HandoffReceipt> {
|
||||
this.pruneExpiredHandoffs();
|
||||
const existing = this.handoffs.get(handoff.handoffId);
|
||||
if (existing !== undefined) {
|
||||
this.assertSameHandoff(existing.handoff, handoff);
|
||||
return this.receipt(existing.handoff, existing.status);
|
||||
}
|
||||
|
||||
const stored: StoredHandoff = {
|
||||
handoff: snapshotHandoff(handoff),
|
||||
status: 'queued',
|
||||
activity: [activity('queued', 'Handoff accepted by the native coordination queue', this.now)],
|
||||
expiresAt: this.now().getTime() + this.handoffTtlMs,
|
||||
};
|
||||
this.handoffs.set(handoff.handoffId, stored);
|
||||
this.enforceHandoffLimit();
|
||||
return this.receipt(stored.handoff, stored.status);
|
||||
}
|
||||
|
||||
async observe(handoffId: string, scope: CoordinationScope): Promise<CoordinationObservation> {
|
||||
this.pruneExpiredHandoffs();
|
||||
const stored = this.requireScopedHandoff(handoffId, scope);
|
||||
return {
|
||||
handoffId: stored.handoff.handoffId,
|
||||
targetAgentId: stored.handoff.targetAgentId,
|
||||
status: stored.status,
|
||||
correlationId: stored.handoff.scope.correlationId,
|
||||
activity: stored.activity.map(copyActivity),
|
||||
};
|
||||
}
|
||||
|
||||
async result(handoffId: string, scope: CoordinationScope): Promise<CoordinationResult> {
|
||||
this.pruneExpiredHandoffs();
|
||||
const stored = this.requireScopedHandoff(handoffId, scope);
|
||||
return (
|
||||
stored.result ?? {
|
||||
handoffId: stored.handoff.handoffId,
|
||||
targetAgentId: stored.handoff.targetAgentId,
|
||||
status: 'pending',
|
||||
correlationId: stored.handoff.scope.correlationId,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
/** Host-side progression seam; interaction clients never receive this capability. */
|
||||
recordActivity(handoffId: string, status: HandoffStatus, summary: string): void {
|
||||
this.pruneExpiredHandoffs();
|
||||
const stored = this.requireHandoff(handoffId);
|
||||
stored.status = status;
|
||||
stored.activity.push(activity(status, summary, this.now));
|
||||
}
|
||||
|
||||
/** Host-side result seam for deterministic qualification; not an orchestrator consumer. */
|
||||
recordResult(handoffId: string, status: 'completed' | 'failed', summary: string): void {
|
||||
this.pruneExpiredHandoffs();
|
||||
const stored = this.requireHandoff(handoffId);
|
||||
stored.status = status;
|
||||
stored.activity.push(activity(status, summary, this.now));
|
||||
stored.result = {
|
||||
handoffId: stored.handoff.handoffId,
|
||||
targetAgentId: stored.handoff.targetAgentId,
|
||||
status,
|
||||
correlationId: stored.handoff.scope.correlationId,
|
||||
summary,
|
||||
};
|
||||
}
|
||||
|
||||
private receipt(handoff: Handoff, status: HandoffStatus): HandoffReceipt {
|
||||
return {
|
||||
handoffId: handoff.handoffId,
|
||||
targetAgentId: handoff.targetAgentId,
|
||||
status: status === 'accepted' ? 'accepted' : 'queued',
|
||||
correlationId: handoff.scope.correlationId,
|
||||
};
|
||||
}
|
||||
|
||||
private pruneExpiredHandoffs(): void {
|
||||
const nowMs = this.now().getTime();
|
||||
for (const [handoffId, handoff] of this.handoffs) {
|
||||
if (handoff.expiresAt <= nowMs) this.handoffs.delete(handoffId);
|
||||
}
|
||||
}
|
||||
|
||||
private enforceHandoffLimit(): void {
|
||||
while (this.handoffs.size > this.maxHandoffs) {
|
||||
const oldest = this.handoffs.keys().next().value;
|
||||
if (typeof oldest !== 'string') return;
|
||||
this.handoffs.delete(oldest);
|
||||
}
|
||||
}
|
||||
|
||||
private requireScopedHandoff(handoffId: string, scope: CoordinationScope): StoredHandoff {
|
||||
const stored = this.requireHandoff(handoffId);
|
||||
if (
|
||||
stored.handoff.scope.tenantId !== scope.tenantId ||
|
||||
stored.handoff.scope.actorId !== scope.actorId ||
|
||||
stored.handoff.scope.requesterAgentId !== scope.requesterAgentId
|
||||
) {
|
||||
throw new InMemoryInteractionCoordinationError('forbidden', 'Handoff scope does not match');
|
||||
}
|
||||
return stored;
|
||||
}
|
||||
|
||||
private requireHandoff(handoffId: string): StoredHandoff {
|
||||
const stored = this.handoffs.get(handoffId);
|
||||
if (stored === undefined) {
|
||||
throw new InMemoryInteractionCoordinationError('not_found', 'Handoff was not found');
|
||||
}
|
||||
return stored;
|
||||
}
|
||||
|
||||
private assertSameHandoff(existing: Handoff, incoming: Handoff): void {
|
||||
if (
|
||||
existing.targetAgentId !== incoming.targetAgentId ||
|
||||
existing.request.idempotencyKey !== incoming.request.idempotencyKey ||
|
||||
existing.request.summary !== incoming.request.summary ||
|
||||
existing.request.context !== incoming.request.context ||
|
||||
existing.request.missionId !== incoming.request.missionId ||
|
||||
existing.scope.actorId !== incoming.scope.actorId ||
|
||||
existing.scope.tenantId !== incoming.scope.tenantId ||
|
||||
existing.scope.correlationId !== incoming.scope.correlationId ||
|
||||
existing.scope.requesterAgentId !== incoming.scope.requesterAgentId
|
||||
) {
|
||||
throw new InMemoryInteractionCoordinationError(
|
||||
'conflict',
|
||||
'Handoff ID is already bound to different immutable input',
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export type InMemoryInteractionCoordinationErrorCode = 'conflict' | 'forbidden' | 'not_found';
|
||||
|
||||
export class InMemoryInteractionCoordinationError extends Error {
|
||||
constructor(
|
||||
readonly code: InMemoryInteractionCoordinationErrorCode,
|
||||
message: string,
|
||||
) {
|
||||
super(message);
|
||||
this.name = InMemoryInteractionCoordinationError.name;
|
||||
}
|
||||
}
|
||||
|
||||
function activity(
|
||||
status: HandoffStatus,
|
||||
summary: string,
|
||||
now: () => Date,
|
||||
): InteractionCoordinationActivity {
|
||||
return { occurredAt: now().toISOString(), status, summary };
|
||||
}
|
||||
|
||||
function copyActivity(entry: InteractionCoordinationActivity): InteractionCoordinationActivity {
|
||||
return { ...entry };
|
||||
}
|
||||
|
||||
function snapshotHandoff(handoff: Handoff): Handoff {
|
||||
return Object.freeze({
|
||||
handoffId: handoff.handoffId,
|
||||
targetAgentId: handoff.targetAgentId,
|
||||
request: Object.freeze({ ...handoff.request }),
|
||||
scope: Object.freeze({ ...handoff.scope }),
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
export { createMission, loadMission, missionFilePath, saveMission } from './mission.js';
|
||||
export { parseTasksFile, updateTaskStatus, writeTasksFile } from './tasks-file.js';
|
||||
export { runTask, resumeTask } from './runner.js';
|
||||
export { getMissionStatus, getTaskStatus } from './status.js';
|
||||
export {
|
||||
InMemoryInteractionCoordinationError,
|
||||
InMemoryInteractionCoordinationPort,
|
||||
} from './in-memory-interaction-coordination-port.js';
|
||||
export {
|
||||
InteractionCoordinationAuthorityError,
|
||||
InteractionCoordinationClient,
|
||||
} from './interaction-coordination.js';
|
||||
export type {
|
||||
CoordinationObservation,
|
||||
CoordinationResult,
|
||||
CoordinationScope,
|
||||
InteractionCoordinationActivity,
|
||||
InteractionCoordinationIdentity,
|
||||
InteractionCoordinationPort,
|
||||
Handoff,
|
||||
HandoffReceipt,
|
||||
HandoffRequest,
|
||||
HandoffStatus,
|
||||
} from './interaction-coordination.js';
|
||||
export type {
|
||||
CreateMissionOptions,
|
||||
Mission,
|
||||
MissionMilestone,
|
||||
MissionRuntime,
|
||||
MissionSession,
|
||||
MissionStatus,
|
||||
MissionStatusSummary,
|
||||
MissionTask,
|
||||
NextTaskCapsule,
|
||||
RunTaskOptions,
|
||||
TaskDetail,
|
||||
TaskRun,
|
||||
TaskStatus,
|
||||
} from './types.js';
|
||||
export { isMissionStatus, isTaskStatus, normalizeTaskStatus } from './types.js';
|
||||
@@ -0,0 +1,209 @@
|
||||
export type HandoffStatus = 'queued' | 'accepted' | 'running' | 'completed' | 'failed';
|
||||
|
||||
export interface CoordinationScope {
|
||||
readonly actorId: string;
|
||||
readonly tenantId: string;
|
||||
readonly correlationId: string;
|
||||
/** Trusted gateway/configuration identity; never supplied by a channel client. */
|
||||
readonly requesterAgentId: string;
|
||||
}
|
||||
|
||||
export interface InteractionCoordinationIdentity {
|
||||
readonly interactionAgentId: string;
|
||||
readonly orchestrationAgentId: string;
|
||||
}
|
||||
|
||||
export interface HandoffRequest {
|
||||
readonly idempotencyKey: string;
|
||||
readonly summary: string;
|
||||
readonly context?: string;
|
||||
readonly missionId?: string;
|
||||
}
|
||||
|
||||
export interface Handoff {
|
||||
readonly handoffId: string;
|
||||
readonly targetAgentId: string;
|
||||
readonly request: HandoffRequest;
|
||||
readonly scope: CoordinationScope;
|
||||
}
|
||||
|
||||
export interface HandoffReceipt {
|
||||
readonly handoffId: string;
|
||||
readonly targetAgentId: string;
|
||||
readonly status: 'queued' | 'accepted';
|
||||
readonly correlationId: string;
|
||||
}
|
||||
|
||||
export interface InteractionCoordinationActivity {
|
||||
readonly occurredAt: string;
|
||||
readonly status: HandoffStatus;
|
||||
readonly summary: string;
|
||||
}
|
||||
|
||||
export interface CoordinationObservation {
|
||||
readonly handoffId: string;
|
||||
readonly targetAgentId: string;
|
||||
readonly status: HandoffStatus;
|
||||
readonly correlationId: string;
|
||||
readonly activity: readonly InteractionCoordinationActivity[];
|
||||
}
|
||||
|
||||
export interface CoordinationResult {
|
||||
readonly handoffId: string;
|
||||
readonly targetAgentId: string;
|
||||
readonly status: 'completed' | 'failed' | 'pending';
|
||||
readonly correlationId: string;
|
||||
readonly summary?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transport-neutral boundary. The interaction plane can request work and read
|
||||
* its progress/result, but it cannot issue worker, review, merge, or other
|
||||
* general orchestration commands.
|
||||
*/
|
||||
export interface InteractionCoordinationPort {
|
||||
handoff(handoff: Handoff): Promise<HandoffReceipt>;
|
||||
observe(handoffId: string, scope: CoordinationScope): Promise<CoordinationObservation>;
|
||||
result(handoffId: string, scope: CoordinationScope): Promise<CoordinationResult>;
|
||||
}
|
||||
|
||||
export type InteractionCoordinationAuthorityErrorCode =
|
||||
| 'invalid_identity'
|
||||
| 'requester_forbidden'
|
||||
| 'target_drift'
|
||||
| 'correlation_drift';
|
||||
|
||||
export class InteractionCoordinationAuthorityError extends Error {
|
||||
constructor(
|
||||
readonly code: InteractionCoordinationAuthorityErrorCode,
|
||||
message: string,
|
||||
) {
|
||||
super(message);
|
||||
this.name = InteractionCoordinationAuthorityError.name;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforces the interaction-to-orchestration authority boundary before a
|
||||
* transport is reached. Identity names remain configuration data.
|
||||
*/
|
||||
export class InteractionCoordinationClient {
|
||||
private readonly identity: InteractionCoordinationIdentity;
|
||||
|
||||
constructor(
|
||||
identity: InteractionCoordinationIdentity,
|
||||
private readonly port: InteractionCoordinationPort,
|
||||
private readonly handoffIdFactory: () => string = (): string => crypto.randomUUID(),
|
||||
) {
|
||||
this.identity = normalizeIdentity(identity);
|
||||
}
|
||||
|
||||
async handoff(request: HandoffRequest, scope: CoordinationScope): Promise<HandoffReceipt> {
|
||||
this.assertRequester(scope);
|
||||
const handoff: Handoff = {
|
||||
handoffId: this.handoffIdFactory(),
|
||||
targetAgentId: this.identity.orchestrationAgentId,
|
||||
request: snapshotRequest(request),
|
||||
scope: snapshotScope(scope),
|
||||
};
|
||||
const receipt = await this.port.handoff(handoff);
|
||||
if (
|
||||
receipt.handoffId !== handoff.handoffId ||
|
||||
receipt.targetAgentId !== handoff.targetAgentId
|
||||
) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'target_drift',
|
||||
'Interaction coordination transport returned a mismatched handoff target',
|
||||
);
|
||||
}
|
||||
if (receipt.correlationId !== handoff.scope.correlationId) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'correlation_drift',
|
||||
'Interaction coordination transport returned a mismatched correlation ID',
|
||||
);
|
||||
}
|
||||
return receipt;
|
||||
}
|
||||
|
||||
async observe(handoffId: string, scope: CoordinationScope): Promise<CoordinationObservation> {
|
||||
this.assertRequester(scope);
|
||||
return this.assertObservation(await this.port.observe(handoffId, snapshotScope(scope)), scope);
|
||||
}
|
||||
|
||||
async result(handoffId: string, scope: CoordinationScope): Promise<CoordinationResult> {
|
||||
this.assertRequester(scope);
|
||||
return this.assertResult(await this.port.result(handoffId, snapshotScope(scope)), scope);
|
||||
}
|
||||
|
||||
private assertRequester(scope: CoordinationScope): void {
|
||||
if (scope.requesterAgentId !== this.identity.interactionAgentId) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'requester_forbidden',
|
||||
'Requester is not the configured interaction agent',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private assertObservation(
|
||||
observation: CoordinationObservation,
|
||||
scope: CoordinationScope,
|
||||
): CoordinationObservation {
|
||||
if (observation.targetAgentId !== this.identity.orchestrationAgentId) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'target_drift',
|
||||
'Interaction coordination transport returned an unexpected observation target',
|
||||
);
|
||||
}
|
||||
if (observation.correlationId !== scope.correlationId) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'correlation_drift',
|
||||
'Interaction coordination transport returned a mismatched observation correlation ID',
|
||||
);
|
||||
}
|
||||
return observation;
|
||||
}
|
||||
|
||||
private assertResult(result: CoordinationResult, scope: CoordinationScope): CoordinationResult {
|
||||
if (result.targetAgentId !== this.identity.orchestrationAgentId) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'target_drift',
|
||||
'Interaction coordination transport returned an unexpected result target',
|
||||
);
|
||||
}
|
||||
if (result.correlationId !== scope.correlationId) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'correlation_drift',
|
||||
'Interaction coordination transport returned a mismatched result correlation ID',
|
||||
);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeIdentity(
|
||||
identity: InteractionCoordinationIdentity,
|
||||
): InteractionCoordinationIdentity {
|
||||
const interactionAgentId = identity.interactionAgentId.trim();
|
||||
const orchestrationAgentId = identity.orchestrationAgentId.trim();
|
||||
if (interactionAgentId.length === 0 || orchestrationAgentId.length === 0) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'invalid_identity',
|
||||
'Interaction and orchestration identities are required',
|
||||
);
|
||||
}
|
||||
if (interactionAgentId === orchestrationAgentId) {
|
||||
throw new InteractionCoordinationAuthorityError(
|
||||
'invalid_identity',
|
||||
'Interaction and orchestration identities must differ',
|
||||
);
|
||||
}
|
||||
return Object.freeze({ interactionAgentId, orchestrationAgentId });
|
||||
}
|
||||
|
||||
function snapshotRequest(request: HandoffRequest): HandoffRequest {
|
||||
return Object.freeze({ ...request });
|
||||
}
|
||||
|
||||
function snapshotScope(scope: CoordinationScope): CoordinationScope {
|
||||
return Object.freeze({ ...scope });
|
||||
}
|
||||
@@ -0,0 +1,395 @@
|
||||
import { promises as fs } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
import { writeTasksFile } from './tasks-file.js';
|
||||
import type { CreateMissionOptions, Mission, MissionMilestone, MissionSession } from './types.js';
|
||||
import { isMissionStatus } from './types.js';
|
||||
|
||||
const DEFAULT_ORCHESTRATOR_DIR = '.mosaic/orchestrator';
|
||||
const DEFAULT_MISSION_FILE = 'mission.json';
|
||||
const DEFAULT_TASKS_FILE = 'docs/TASKS.md';
|
||||
const DEFAULT_MANIFEST_FILE = 'docs/MISSION-MANIFEST.md';
|
||||
const DEFAULT_SCRATCHPAD_DIR = 'docs/scratchpads';
|
||||
const DEFAULT_MILESTONE_VERSION = '0.0.1';
|
||||
|
||||
function asRecord(value: unknown): Record<string, unknown> {
|
||||
if (typeof value === 'object' && value !== null) {
|
||||
return value as Record<string, unknown>;
|
||||
}
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
function readString(
|
||||
source: Record<string, unknown>,
|
||||
...keys: readonly string[]
|
||||
): string | undefined {
|
||||
for (const key of keys) {
|
||||
const value = source[key];
|
||||
if (typeof value === 'string') {
|
||||
const trimmed = value.trim();
|
||||
if (trimmed.length > 0) {
|
||||
return trimmed;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function readNumber(
|
||||
source: Record<string, unknown>,
|
||||
...keys: readonly string[]
|
||||
): number | undefined {
|
||||
for (const key of keys) {
|
||||
const value = source[key];
|
||||
if (typeof value === 'number' && Number.isFinite(value)) {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function normalizeMilestoneStatus(status: string | undefined): MissionMilestone['status'] {
|
||||
if (status === 'completed') return 'completed';
|
||||
if (status === 'in-progress') return 'in-progress';
|
||||
if (status === 'blocked') return 'blocked';
|
||||
return 'pending';
|
||||
}
|
||||
|
||||
function normalizeSessionRuntime(runtime: string | undefined): MissionSession['runtime'] {
|
||||
if (runtime === 'claude' || runtime === 'codex' || runtime === 'unknown') {
|
||||
return runtime;
|
||||
}
|
||||
return 'unknown';
|
||||
}
|
||||
|
||||
function normalizeEndedReason(reason: string | undefined): MissionSession['endedReason'] {
|
||||
if (
|
||||
reason === 'completed' ||
|
||||
reason === 'paused' ||
|
||||
reason === 'crashed' ||
|
||||
reason === 'killed' ||
|
||||
reason === 'unknown'
|
||||
) {
|
||||
return reason;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function normalizeMission(raw: unknown, resolvedProjectPath: string): Mission {
|
||||
const source = asRecord(raw);
|
||||
|
||||
const id = readString(source, 'id', 'mission_id') ?? 'mission';
|
||||
const name = readString(source, 'name') ?? 'Unnamed Mission';
|
||||
const statusCandidate = readString(source, 'status') ?? 'inactive';
|
||||
const status = isMissionStatus(statusCandidate) ? statusCandidate : 'inactive';
|
||||
|
||||
const mission: Mission = {
|
||||
schemaVersion: 1,
|
||||
id,
|
||||
name,
|
||||
description: readString(source, 'description'),
|
||||
projectPath: readString(source, 'projectPath', 'project_path') ?? resolvedProjectPath,
|
||||
createdAt: readString(source, 'createdAt', 'created_at') ?? new Date().toISOString(),
|
||||
status,
|
||||
tasksFile: readString(source, 'tasksFile', 'tasks_file') ?? DEFAULT_TASKS_FILE,
|
||||
manifestFile: readString(source, 'manifestFile', 'manifest_file') ?? DEFAULT_MANIFEST_FILE,
|
||||
scratchpadFile:
|
||||
readString(source, 'scratchpadFile', 'scratchpad_file') ??
|
||||
`${DEFAULT_SCRATCHPAD_DIR}/${id}.md`,
|
||||
orchestratorDir:
|
||||
readString(source, 'orchestratorDir', 'orchestrator_dir') ?? DEFAULT_ORCHESTRATOR_DIR,
|
||||
taskPrefix: readString(source, 'taskPrefix', 'task_prefix'),
|
||||
qualityGates: readString(source, 'qualityGates', 'quality_gates'),
|
||||
milestoneVersion: readString(source, 'milestoneVersion', 'milestone_version'),
|
||||
milestones: [],
|
||||
sessions: [],
|
||||
};
|
||||
|
||||
const milestonesRaw = Array.isArray(source.milestones) ? source.milestones : [];
|
||||
mission.milestones = milestonesRaw.map(
|
||||
(milestoneValue: unknown, index: number): MissionMilestone => {
|
||||
const milestone = asRecord(milestoneValue);
|
||||
return {
|
||||
id: readString(milestone, 'id') ?? `phase-${index + 1}`,
|
||||
name: readString(milestone, 'name') ?? `Phase ${index + 1}`,
|
||||
status: normalizeMilestoneStatus(readString(milestone, 'status')),
|
||||
branch: readString(milestone, 'branch'),
|
||||
issueRef: readString(milestone, 'issueRef', 'issue_ref'),
|
||||
startedAt: readString(milestone, 'startedAt', 'started_at'),
|
||||
completedAt: readString(milestone, 'completedAt', 'completed_at'),
|
||||
};
|
||||
},
|
||||
);
|
||||
|
||||
const sessionsRaw = Array.isArray(source.sessions) ? source.sessions : [];
|
||||
mission.sessions = sessionsRaw.map((sessionValue: unknown, index: number): MissionSession => {
|
||||
const session = asRecord(sessionValue);
|
||||
const fallbackSessionId = `sess-${String(index + 1).padStart(3, '0')}`;
|
||||
|
||||
return {
|
||||
sessionId: readString(session, 'sessionId', 'session_id') ?? fallbackSessionId,
|
||||
runtime: normalizeSessionRuntime(readString(session, 'runtime')),
|
||||
pid: readNumber(session, 'pid'),
|
||||
startedAt: readString(session, 'startedAt', 'started_at') ?? mission.createdAt,
|
||||
endedAt: readString(session, 'endedAt', 'ended_at'),
|
||||
endedReason: normalizeEndedReason(readString(session, 'endedReason', 'ended_reason')),
|
||||
milestoneId: readString(session, 'milestoneId', 'milestone_id'),
|
||||
lastTaskId: readString(session, 'lastTaskId', 'last_task_id'),
|
||||
durationSeconds: readNumber(session, 'durationSeconds', 'duration_seconds'),
|
||||
};
|
||||
});
|
||||
|
||||
return mission;
|
||||
}
|
||||
|
||||
function missionIdFromName(name: string): string {
|
||||
const slug = name
|
||||
.toLowerCase()
|
||||
.replace(/[^a-z0-9]+/g, '-')
|
||||
.replace(/^-+|-+$/g, '')
|
||||
.replace(/-{2,}/g, '-');
|
||||
const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
|
||||
return `${slug || 'mission'}-${date}`;
|
||||
}
|
||||
|
||||
function toAbsolutePath(basePath: string, targetPath: string): string {
|
||||
if (path.isAbsolute(targetPath)) {
|
||||
return targetPath;
|
||||
}
|
||||
return path.join(basePath, targetPath);
|
||||
}
|
||||
|
||||
function isNodeErrorWithCode(error: unknown, code: string): boolean {
|
||||
return (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
(error as { code?: string }).code === code
|
||||
);
|
||||
}
|
||||
|
||||
async function fileExists(filePath: string): Promise<boolean> {
|
||||
try {
|
||||
await fs.access(filePath);
|
||||
return true;
|
||||
} catch (error) {
|
||||
if (isNodeErrorWithCode(error, 'ENOENT')) {
|
||||
return false;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
async function writeFileAtomic(filePath: string, content: string): Promise<void> {
|
||||
const directory = path.dirname(filePath);
|
||||
await fs.mkdir(directory, { recursive: true });
|
||||
|
||||
const tempPath = path.join(
|
||||
directory,
|
||||
`.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}-${Math.random()
|
||||
.toString(16)
|
||||
.slice(2)}`,
|
||||
);
|
||||
|
||||
await fs.writeFile(tempPath, content, 'utf8');
|
||||
await fs.rename(tempPath, filePath);
|
||||
}
|
||||
|
||||
function renderManifest(mission: Mission): string {
|
||||
const milestoneRows = mission.milestones
|
||||
.map((milestone, index) => {
|
||||
const issue = milestone.issueRef ?? '—';
|
||||
const branch = milestone.branch ?? '—';
|
||||
const started = milestone.startedAt ?? '—';
|
||||
const completed = milestone.completedAt ?? '—';
|
||||
return `| ${index + 1} | ${milestone.id} | ${milestone.name} | ${milestone.status} | ${branch} | ${issue} | ${started} | ${completed} |`;
|
||||
})
|
||||
.join('\n');
|
||||
|
||||
const body = [
|
||||
`# Mission Manifest — ${mission.name}`,
|
||||
'',
|
||||
'> Persistent document tracking full mission scope, status, and session history.',
|
||||
'',
|
||||
'## Mission',
|
||||
'',
|
||||
`**ID:** ${mission.id}`,
|
||||
`**Statement:** ${mission.description ?? ''}`,
|
||||
'**Phase:** Intake',
|
||||
'**Current Milestone:** —',
|
||||
`**Progress:** 0 / ${mission.milestones.length} milestones`,
|
||||
`**Status:** ${mission.status}`,
|
||||
`**Last Updated:** ${new Date().toISOString().replace('T', ' ').replace(/\..+/, ' UTC')}`,
|
||||
'',
|
||||
'## Milestones',
|
||||
'',
|
||||
'| # | ID | Name | Status | Branch | Issue | Started | Completed |',
|
||||
'|---|-----|------|--------|--------|-------|---------|-----------|',
|
||||
milestoneRows,
|
||||
'',
|
||||
'## Session History',
|
||||
'',
|
||||
'| Session | Runtime | Started | Duration | Ended Reason | Last Task |',
|
||||
'|---------|---------|---------|----------|--------------|-----------|',
|
||||
'',
|
||||
`## Scratchpad\n\nPath: \`${mission.scratchpadFile}\``,
|
||||
'',
|
||||
];
|
||||
|
||||
return body.join('\n');
|
||||
}
|
||||
|
||||
function renderScratchpad(mission: Mission): string {
|
||||
return [
|
||||
`# Mission Scratchpad — ${mission.name}`,
|
||||
'',
|
||||
'> Append-only log. NEVER delete entries. NEVER overwrite sections.',
|
||||
'',
|
||||
'## Original Mission Prompt',
|
||||
'',
|
||||
'```',
|
||||
'(Paste the mission prompt here on first session)',
|
||||
'```',
|
||||
'',
|
||||
'## Planning Decisions',
|
||||
'',
|
||||
'## Session Log',
|
||||
'',
|
||||
'| Session | Date | Milestone | Tasks Done | Outcome |',
|
||||
'|---------|------|-----------|------------|---------|',
|
||||
'',
|
||||
'## Open Questions',
|
||||
'',
|
||||
'## Corrections',
|
||||
'',
|
||||
].join('\n');
|
||||
}
|
||||
|
||||
function buildMissionFromOptions(
|
||||
options: CreateMissionOptions,
|
||||
resolvedProjectPath: string,
|
||||
): Mission {
|
||||
const id = missionIdFromName(options.name);
|
||||
const milestones = (options.milestones ?? []).map((name, index): MissionMilestone => {
|
||||
const cleanName = name.trim();
|
||||
const milestoneName = cleanName.length > 0 ? cleanName : `Phase ${index + 1}`;
|
||||
return {
|
||||
id: `phase-${index + 1}`,
|
||||
name: milestoneName,
|
||||
status: 'pending' as const,
|
||||
branch: milestoneName
|
||||
.toLowerCase()
|
||||
.replace(/[^a-z0-9]+/g, '-')
|
||||
.replace(/^-+|-+$/g, ''),
|
||||
};
|
||||
});
|
||||
|
||||
return {
|
||||
schemaVersion: 1,
|
||||
id,
|
||||
name: options.name,
|
||||
description: options.description,
|
||||
projectPath: resolvedProjectPath,
|
||||
createdAt: new Date().toISOString(),
|
||||
status: 'active',
|
||||
tasksFile: DEFAULT_TASKS_FILE,
|
||||
manifestFile: DEFAULT_MANIFEST_FILE,
|
||||
scratchpadFile: `${DEFAULT_SCRATCHPAD_DIR}/${id}.md`,
|
||||
orchestratorDir: DEFAULT_ORCHESTRATOR_DIR,
|
||||
taskPrefix: options.prefix,
|
||||
qualityGates: options.qualityGates,
|
||||
milestoneVersion: options.version ?? DEFAULT_MILESTONE_VERSION,
|
||||
milestones,
|
||||
sessions: [],
|
||||
};
|
||||
}
|
||||
|
||||
export function missionFilePath(projectPath: string, mission?: Mission): string {
|
||||
const orchestratorDir = mission?.orchestratorDir ?? DEFAULT_ORCHESTRATOR_DIR;
|
||||
const baseDir = path.isAbsolute(orchestratorDir)
|
||||
? orchestratorDir
|
||||
: path.join(projectPath, orchestratorDir);
|
||||
return path.join(baseDir, DEFAULT_MISSION_FILE);
|
||||
}
|
||||
|
||||
export async function saveMission(mission: Mission): Promise<void> {
|
||||
const filePath = missionFilePath(mission.projectPath, mission);
|
||||
const payload = `${JSON.stringify(mission, null, 2)}\n`;
|
||||
await writeFileAtomic(filePath, payload);
|
||||
}
|
||||
|
||||
export async function createMission(options: CreateMissionOptions): Promise<Mission> {
|
||||
const name = options.name.trim();
|
||||
if (name.length === 0) {
|
||||
throw new Error('Mission name is required');
|
||||
}
|
||||
|
||||
const resolvedProjectPath = path.resolve(options.projectPath ?? process.cwd());
|
||||
const mission = buildMissionFromOptions({ ...options, name }, resolvedProjectPath);
|
||||
|
||||
const missionPath = missionFilePath(resolvedProjectPath, mission);
|
||||
const hasExistingMission = await fileExists(missionPath);
|
||||
|
||||
if (hasExistingMission) {
|
||||
const existingRaw = await fs.readFile(missionPath, 'utf8');
|
||||
const existingMission = normalizeMission(JSON.parse(existingRaw), resolvedProjectPath);
|
||||
const active = existingMission.status === 'active' || existingMission.status === 'paused';
|
||||
if (active && options.force !== true) {
|
||||
throw new Error(
|
||||
`Active mission exists: ${existingMission.name} (${existingMission.status}). Use force to overwrite.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
await saveMission(mission);
|
||||
|
||||
const manifestPath = toAbsolutePath(resolvedProjectPath, mission.manifestFile);
|
||||
const scratchpadPath = toAbsolutePath(resolvedProjectPath, mission.scratchpadFile);
|
||||
const tasksPath = toAbsolutePath(resolvedProjectPath, mission.tasksFile);
|
||||
|
||||
if (options.force === true || !(await fileExists(manifestPath))) {
|
||||
await writeFileAtomic(manifestPath, renderManifest(mission));
|
||||
}
|
||||
|
||||
if (!(await fileExists(scratchpadPath))) {
|
||||
await writeFileAtomic(scratchpadPath, renderScratchpad(mission));
|
||||
}
|
||||
|
||||
if (!(await fileExists(tasksPath))) {
|
||||
await writeFileAtomic(tasksPath, writeTasksFile([]));
|
||||
}
|
||||
|
||||
return mission;
|
||||
}
|
||||
|
||||
export async function loadMission(projectPath: string): Promise<Mission> {
|
||||
const resolvedProjectPath = path.resolve(projectPath);
|
||||
const filePath = missionFilePath(resolvedProjectPath);
|
||||
|
||||
let raw: string;
|
||||
try {
|
||||
raw = await fs.readFile(filePath, 'utf8');
|
||||
} catch (error) {
|
||||
if (isNodeErrorWithCode(error, 'ENOENT')) {
|
||||
throw new Error(`No mission found at ${filePath}`);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
|
||||
let parsed: unknown;
|
||||
try {
|
||||
parsed = JSON.parse(raw);
|
||||
} catch {
|
||||
throw new Error(`Invalid JSON in mission file: ${filePath}`);
|
||||
}
|
||||
|
||||
const mission = normalizeMission(parsed, resolvedProjectPath);
|
||||
if (mission.status === 'inactive') {
|
||||
throw new Error('Mission exists but is inactive. Re-initialize with mosaic coord init.');
|
||||
}
|
||||
|
||||
return mission;
|
||||
}
|
||||
@@ -0,0 +1,481 @@
|
||||
import { spawn, spawnSync } from 'node:child_process';
|
||||
import { promises as fs } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
import { loadMission, saveMission } from './mission.js';
|
||||
import { parseTasksFile, updateTaskStatus } from './tasks-file.js';
|
||||
import type {
|
||||
Mission,
|
||||
MissionMilestone,
|
||||
MissionSession,
|
||||
RunTaskOptions,
|
||||
TaskRun,
|
||||
} from './types.js';
|
||||
|
||||
const SESSION_LOCK_FILE = 'session.lock';
|
||||
const NEXT_TASK_FILE = 'next-task.json';
|
||||
|
||||
interface SessionLockState {
|
||||
session_id: string;
|
||||
runtime: 'claude' | 'codex';
|
||||
pid: number;
|
||||
started_at: string;
|
||||
project_path: string;
|
||||
milestone_id?: string;
|
||||
}
|
||||
|
||||
function orchestratorDirPath(mission: Mission): string {
|
||||
if (path.isAbsolute(mission.orchestratorDir)) {
|
||||
return mission.orchestratorDir;
|
||||
}
|
||||
return path.join(mission.projectPath, mission.orchestratorDir);
|
||||
}
|
||||
|
||||
function sessionLockPath(mission: Mission): string {
|
||||
return path.join(orchestratorDirPath(mission), SESSION_LOCK_FILE);
|
||||
}
|
||||
|
||||
function nextTaskCapsulePath(mission: Mission): string {
|
||||
return path.join(orchestratorDirPath(mission), NEXT_TASK_FILE);
|
||||
}
|
||||
|
||||
function tasksFilePath(mission: Mission): string {
|
||||
if (path.isAbsolute(mission.tasksFile)) {
|
||||
return mission.tasksFile;
|
||||
}
|
||||
return path.join(mission.projectPath, mission.tasksFile);
|
||||
}
|
||||
|
||||
function buildSessionId(mission: Mission): string {
|
||||
return `sess-${String(mission.sessions.length + 1).padStart(3, '0')}`;
|
||||
}
|
||||
|
||||
function isPidAlive(pid: number): boolean {
|
||||
try {
|
||||
process.kill(pid, 0);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function currentMilestone(mission: Mission): MissionMilestone | undefined {
|
||||
return (
|
||||
mission.milestones.find((milestone) => milestone.status === 'in-progress') ??
|
||||
mission.milestones.find((milestone) => milestone.status === 'pending')
|
||||
);
|
||||
}
|
||||
|
||||
async function readTasks(mission: Mission) {
|
||||
const filePath = tasksFilePath(mission);
|
||||
|
||||
try {
|
||||
const content = await fs.readFile(filePath, 'utf8');
|
||||
return parseTasksFile(content);
|
||||
} catch (error) {
|
||||
if (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
(error as { code?: string }).code === 'ENOENT'
|
||||
) {
|
||||
return [];
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
function currentBranch(projectPath: string): string | undefined {
|
||||
const result = spawnSync('git', ['-C', projectPath, 'branch', '--show-current'], {
|
||||
encoding: 'utf8',
|
||||
});
|
||||
|
||||
if (result.status !== 0) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const branch = result.stdout.trim();
|
||||
return branch.length > 0 ? branch : undefined;
|
||||
}
|
||||
|
||||
function percentage(done: number, total: number): number {
|
||||
if (total === 0) return 0;
|
||||
return Math.floor((done / total) * 100);
|
||||
}
|
||||
|
||||
function formatDurationSeconds(totalSeconds: number): string {
|
||||
if (totalSeconds < 60) return `${totalSeconds}s`;
|
||||
|
||||
if (totalSeconds < 3600) {
|
||||
const minutes = Math.floor(totalSeconds / 60);
|
||||
const seconds = totalSeconds % 60;
|
||||
return `${minutes}m ${seconds}s`;
|
||||
}
|
||||
|
||||
const hours = Math.floor(totalSeconds / 3600);
|
||||
const minutes = Math.floor((totalSeconds % 3600) / 60);
|
||||
return `${hours}h ${minutes}m`;
|
||||
}
|
||||
|
||||
function buildContinuationPrompt(params: {
|
||||
mission: Mission;
|
||||
taskId: string;
|
||||
runtime: 'claude' | 'codex';
|
||||
tasksDone: number;
|
||||
tasksTotal: number;
|
||||
currentMilestone?: MissionMilestone;
|
||||
previousSession?: MissionSession;
|
||||
branch?: string;
|
||||
}): string {
|
||||
const {
|
||||
mission,
|
||||
taskId,
|
||||
runtime,
|
||||
tasksDone,
|
||||
tasksTotal,
|
||||
currentMilestone: milestone,
|
||||
previousSession,
|
||||
branch,
|
||||
} = params;
|
||||
|
||||
const pct = percentage(tasksDone, tasksTotal);
|
||||
const previousDuration =
|
||||
previousSession?.durationSeconds !== undefined
|
||||
? formatDurationSeconds(previousSession.durationSeconds)
|
||||
: '—';
|
||||
|
||||
return [
|
||||
'## Continuation Mission',
|
||||
'',
|
||||
`Continue **${mission.name}** from existing state.`,
|
||||
'',
|
||||
'## Setup',
|
||||
'',
|
||||
`- **Project:** ${mission.projectPath}`,
|
||||
`- **State:** ${mission.tasksFile} (${tasksDone}/${tasksTotal} tasks complete)`,
|
||||
`- **Manifest:** ${mission.manifestFile}`,
|
||||
`- **Scratchpad:** ${mission.scratchpadFile}`,
|
||||
'- **Protocol:** ~/.config/mosaic/guides/ORCHESTRATOR.md',
|
||||
`- **Quality gates:** ${mission.qualityGates ?? '—'}`,
|
||||
`- **Target runtime:** ${runtime}`,
|
||||
'',
|
||||
'## Resume Point',
|
||||
'',
|
||||
`- **Current milestone:** ${milestone?.name ?? '—'} (${milestone?.id ?? '—'})`,
|
||||
`- **Next task:** ${taskId}`,
|
||||
`- **Progress:** ${tasksDone}/${tasksTotal} (${pct}%)`,
|
||||
`- **Branch:** ${branch ?? '—'}`,
|
||||
'',
|
||||
'## Previous Session Context',
|
||||
'',
|
||||
`- **Session:** ${previousSession?.sessionId ?? '—'} (${previousSession?.runtime ?? '—'}, ${previousDuration})`,
|
||||
`- **Ended:** ${previousSession?.endedReason ?? '—'}`,
|
||||
`- **Last completed task:** ${previousSession?.lastTaskId ?? '—'}`,
|
||||
'',
|
||||
'## Instructions',
|
||||
'',
|
||||
'1. Read `~/.config/mosaic/guides/ORCHESTRATOR.md` for full protocol',
|
||||
`2. Read \`${mission.manifestFile}\` for mission scope and status`,
|
||||
`3. Read \`${mission.scratchpadFile}\` for session history and decisions`,
|
||||
`4. Read \`${mission.tasksFile}\` for current task state`,
|
||||
'5. `git pull --rebase` to sync latest changes',
|
||||
`6. Launch runtime with \`mosaic ${runtime} -p\``,
|
||||
`7. Continue execution from task **${taskId}**`,
|
||||
'8. Follow Two-Phase Completion Protocol',
|
||||
`9. You are the SOLE writer of \`${mission.tasksFile}\``,
|
||||
].join('\n');
|
||||
}
|
||||
|
||||
export function resolveLaunchCommand(
|
||||
runtime: 'claude' | 'codex',
|
||||
prompt: string,
|
||||
configuredCommand: string[] | undefined,
|
||||
): string[] {
|
||||
if (configuredCommand === undefined || configuredCommand.length === 0) {
|
||||
return runtime === 'claude' ? ['mosaic', 'claude', '-p', prompt] : [runtime, '-p', prompt];
|
||||
}
|
||||
|
||||
const hasPromptPlaceholder = configuredCommand.some((value) => value === '{prompt}');
|
||||
const withInterpolation = configuredCommand.map((value) =>
|
||||
value === '{prompt}' ? prompt : value,
|
||||
);
|
||||
const command = hasPromptPlaceholder ? withInterpolation : [...withInterpolation, prompt];
|
||||
|
||||
if (runtime !== 'claude') return command;
|
||||
if (
|
||||
command[0] === 'mosaic' &&
|
||||
(command[1] === 'claude' || (command[1] === 'yolo' && command[2] === 'claude'))
|
||||
) {
|
||||
return command;
|
||||
}
|
||||
if (command[0] === 'claude') {
|
||||
return ['mosaic', 'claude', ...command.slice(1)];
|
||||
}
|
||||
throw new Error(
|
||||
'Custom Claude task commands must use `mosaic claude` so lease registration cannot be bypassed.',
|
||||
);
|
||||
}
|
||||
|
||||
async function writeAtomicJson(filePath: string, payload: unknown): Promise<void> {
|
||||
const directory = path.dirname(filePath);
|
||||
await fs.mkdir(directory, { recursive: true });
|
||||
|
||||
const tempPath = path.join(
|
||||
directory,
|
||||
`.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}-${Math.random()
|
||||
.toString(16)
|
||||
.slice(2)}`,
|
||||
);
|
||||
|
||||
await fs.writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
|
||||
await fs.rename(tempPath, filePath);
|
||||
}
|
||||
|
||||
async function readSessionLock(mission: Mission): Promise<SessionLockState | undefined> {
|
||||
const filePath = sessionLockPath(mission);
|
||||
|
||||
let raw: string;
|
||||
try {
|
||||
raw = await fs.readFile(filePath, 'utf8');
|
||||
} catch (error) {
|
||||
if (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
(error as { code?: string }).code === 'ENOENT'
|
||||
) {
|
||||
return undefined;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
|
||||
let data: Partial<SessionLockState>;
|
||||
try {
|
||||
data = JSON.parse(raw) as Partial<SessionLockState>;
|
||||
} catch {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (
|
||||
typeof data.session_id !== 'string' ||
|
||||
(data.runtime !== 'claude' && data.runtime !== 'codex') ||
|
||||
typeof data.pid !== 'number' ||
|
||||
typeof data.started_at !== 'string' ||
|
||||
typeof data.project_path !== 'string'
|
||||
) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return {
|
||||
session_id: data.session_id,
|
||||
runtime: data.runtime,
|
||||
pid: data.pid,
|
||||
started_at: data.started_at,
|
||||
project_path: data.project_path,
|
||||
milestone_id: data.milestone_id,
|
||||
};
|
||||
}
|
||||
|
||||
async function writeSessionLock(mission: Mission, lock: SessionLockState): Promise<void> {
|
||||
await writeAtomicJson(sessionLockPath(mission), lock);
|
||||
}
|
||||
|
||||
function markSessionCrashed(mission: Mission, sessionId: string, endedAt: string): Mission {
|
||||
const sessions = mission.sessions.map((session) => {
|
||||
if (session.sessionId !== sessionId) return session;
|
||||
if (session.endedAt !== undefined) return session;
|
||||
|
||||
const startedEpoch = Date.parse(session.startedAt);
|
||||
const endedEpoch = Date.parse(endedAt);
|
||||
const durationSeconds =
|
||||
Number.isFinite(startedEpoch) && Number.isFinite(endedEpoch)
|
||||
? Math.max(0, Math.floor((endedEpoch - startedEpoch) / 1000))
|
||||
: undefined;
|
||||
|
||||
return {
|
||||
...session,
|
||||
endedAt,
|
||||
endedReason: 'crashed' as const,
|
||||
durationSeconds,
|
||||
};
|
||||
});
|
||||
|
||||
return { ...mission, sessions };
|
||||
}
|
||||
|
||||
export async function runTask(
|
||||
mission: Mission,
|
||||
taskId: string,
|
||||
options: RunTaskOptions = {},
|
||||
): Promise<TaskRun> {
|
||||
const runtime = options.runtime ?? 'claude';
|
||||
const mode = options.mode ?? 'interactive';
|
||||
|
||||
const freshMission = await loadMission(mission.projectPath);
|
||||
const tasks = await readTasks(freshMission);
|
||||
const matches = tasks.filter((task) => task.id === taskId);
|
||||
|
||||
if (matches.length === 0) {
|
||||
throw new Error(`Task not found: ${taskId}`);
|
||||
}
|
||||
|
||||
if (matches.length > 1) {
|
||||
throw new Error(`Duplicate task IDs found: ${taskId}`);
|
||||
}
|
||||
|
||||
const task = matches[0]!;
|
||||
if (task.status === 'done' || task.status === 'cancelled') {
|
||||
throw new Error(`Task ${taskId} cannot be run from status ${task.status}`);
|
||||
}
|
||||
|
||||
const tasksTotal = tasks.length;
|
||||
const tasksDone = tasks.filter((candidate) => candidate.status === 'done').length;
|
||||
const selectedMilestone =
|
||||
freshMission.milestones.find((milestone) => milestone.id === options.milestoneId) ??
|
||||
freshMission.milestones.find((milestone) => milestone.id === task.milestone) ??
|
||||
currentMilestone(freshMission);
|
||||
|
||||
const continuationPrompt = buildContinuationPrompt({
|
||||
mission: freshMission,
|
||||
taskId,
|
||||
runtime,
|
||||
tasksDone,
|
||||
tasksTotal,
|
||||
currentMilestone: selectedMilestone,
|
||||
previousSession: freshMission.sessions.at(-1),
|
||||
branch: currentBranch(freshMission.projectPath),
|
||||
});
|
||||
|
||||
const launchCommand = resolveLaunchCommand(runtime, continuationPrompt, options.command);
|
||||
const startedAt = new Date().toISOString();
|
||||
const sessionId = buildSessionId(freshMission);
|
||||
const lockFile = sessionLockPath(freshMission);
|
||||
|
||||
await writeAtomicJson(nextTaskCapsulePath(freshMission), {
|
||||
generated_at: startedAt,
|
||||
runtime,
|
||||
mission_id: freshMission.id,
|
||||
mission_name: freshMission.name,
|
||||
project_path: freshMission.projectPath,
|
||||
quality_gates: freshMission.qualityGates ?? '',
|
||||
current_milestone: {
|
||||
id: selectedMilestone?.id ?? '',
|
||||
name: selectedMilestone?.name ?? '',
|
||||
},
|
||||
next_task: taskId,
|
||||
progress: {
|
||||
tasks_done: tasksDone,
|
||||
tasks_total: tasksTotal,
|
||||
pct: percentage(tasksDone, tasksTotal),
|
||||
},
|
||||
current_branch: currentBranch(freshMission.projectPath) ?? '',
|
||||
});
|
||||
|
||||
if (mode === 'print-only') {
|
||||
return {
|
||||
missionId: freshMission.id,
|
||||
taskId,
|
||||
sessionId,
|
||||
runtime,
|
||||
launchCommand,
|
||||
startedAt,
|
||||
lockFile,
|
||||
};
|
||||
}
|
||||
|
||||
await updateTaskStatus(freshMission, taskId, 'in-progress');
|
||||
|
||||
await writeSessionLock(freshMission, {
|
||||
session_id: sessionId,
|
||||
runtime,
|
||||
pid: 0,
|
||||
started_at: startedAt,
|
||||
project_path: freshMission.projectPath,
|
||||
milestone_id: selectedMilestone?.id,
|
||||
});
|
||||
|
||||
const child = spawn(launchCommand[0]!, launchCommand.slice(1), {
|
||||
cwd: freshMission.projectPath,
|
||||
env: {
|
||||
...process.env,
|
||||
...(options.env ?? {}),
|
||||
},
|
||||
stdio: 'inherit',
|
||||
});
|
||||
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
child.once('spawn', () => {
|
||||
resolve();
|
||||
});
|
||||
child.once('error', (error) => {
|
||||
reject(error);
|
||||
});
|
||||
});
|
||||
|
||||
const pid = child.pid;
|
||||
if (pid === undefined) {
|
||||
throw new Error('Failed to start task runtime process (pid missing)');
|
||||
}
|
||||
|
||||
await writeSessionLock(freshMission, {
|
||||
session_id: sessionId,
|
||||
runtime,
|
||||
pid,
|
||||
started_at: startedAt,
|
||||
project_path: freshMission.projectPath,
|
||||
milestone_id: selectedMilestone?.id,
|
||||
});
|
||||
|
||||
const updatedMission: Mission = {
|
||||
...freshMission,
|
||||
status: 'active',
|
||||
sessions: [
|
||||
...freshMission.sessions,
|
||||
{
|
||||
sessionId,
|
||||
runtime,
|
||||
pid,
|
||||
startedAt,
|
||||
milestoneId: selectedMilestone?.id,
|
||||
lastTaskId: taskId,
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
await saveMission(updatedMission);
|
||||
|
||||
return {
|
||||
missionId: updatedMission.id,
|
||||
taskId,
|
||||
sessionId,
|
||||
runtime,
|
||||
launchCommand,
|
||||
startedAt,
|
||||
pid,
|
||||
lockFile,
|
||||
};
|
||||
}
|
||||
|
||||
export async function resumeTask(
|
||||
mission: Mission,
|
||||
taskId: string,
|
||||
options: Omit<RunTaskOptions, 'milestoneId'> = {},
|
||||
): Promise<TaskRun> {
|
||||
const freshMission = await loadMission(mission.projectPath);
|
||||
const lock = await readSessionLock(freshMission);
|
||||
|
||||
if (lock !== undefined && lock.pid > 0 && isPidAlive(lock.pid)) {
|
||||
throw new Error(`Session ${lock.session_id} is still running (PID ${lock.pid}).`);
|
||||
}
|
||||
|
||||
let nextMissionState = freshMission;
|
||||
|
||||
if (lock !== undefined) {
|
||||
const endedAt = new Date().toISOString();
|
||||
nextMissionState = markSessionCrashed(freshMission, lock.session_id, endedAt);
|
||||
await saveMission(nextMissionState);
|
||||
await fs.rm(sessionLockPath(nextMissionState), { force: true });
|
||||
}
|
||||
|
||||
return runTask(nextMissionState, taskId, options);
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
import { promises as fs } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
import { loadMission } from './mission.js';
|
||||
import { parseTasksFile } from './tasks-file.js';
|
||||
import type {
|
||||
Mission,
|
||||
MissionSession,
|
||||
MissionStatusSummary,
|
||||
MissionTask,
|
||||
TaskDetail,
|
||||
} from './types.js';
|
||||
|
||||
const SESSION_LOCK_FILE = 'session.lock';
|
||||
|
||||
interface SessionLockState {
|
||||
session_id?: string;
|
||||
runtime?: string;
|
||||
pid?: number;
|
||||
started_at?: string;
|
||||
milestone_id?: string;
|
||||
}
|
||||
|
||||
function tasksFilePath(mission: Mission): string {
|
||||
if (path.isAbsolute(mission.tasksFile)) {
|
||||
return mission.tasksFile;
|
||||
}
|
||||
return path.join(mission.projectPath, mission.tasksFile);
|
||||
}
|
||||
|
||||
function sessionLockPath(mission: Mission): string {
|
||||
const orchestratorDir = path.isAbsolute(mission.orchestratorDir)
|
||||
? mission.orchestratorDir
|
||||
: path.join(mission.projectPath, mission.orchestratorDir);
|
||||
|
||||
return path.join(orchestratorDir, SESSION_LOCK_FILE);
|
||||
}
|
||||
|
||||
function isPidAlive(pid: number): boolean {
|
||||
try {
|
||||
process.kill(pid, 0);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
async function readTasks(mission: Mission): Promise<MissionTask[]> {
|
||||
try {
|
||||
const content = await fs.readFile(tasksFilePath(mission), 'utf8');
|
||||
return parseTasksFile(content);
|
||||
} catch (error) {
|
||||
if (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
(error as { code?: string }).code === 'ENOENT'
|
||||
) {
|
||||
return [];
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
async function readActiveSession(mission: Mission): Promise<MissionSession | undefined> {
|
||||
let lockRaw: string;
|
||||
try {
|
||||
lockRaw = await fs.readFile(sessionLockPath(mission), 'utf8');
|
||||
} catch (error) {
|
||||
if (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
(error as { code?: string }).code === 'ENOENT'
|
||||
) {
|
||||
return undefined;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
|
||||
let lock: SessionLockState;
|
||||
try {
|
||||
lock = JSON.parse(lockRaw) as SessionLockState;
|
||||
} catch {
|
||||
return undefined;
|
||||
}
|
||||
if (
|
||||
typeof lock.session_id !== 'string' ||
|
||||
(lock.runtime !== 'claude' && lock.runtime !== 'codex') ||
|
||||
typeof lock.started_at !== 'string'
|
||||
) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const pid = typeof lock.pid === 'number' ? lock.pid : undefined;
|
||||
if (pid !== undefined && pid > 0 && !isPidAlive(pid)) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const existingSession = mission.sessions.find((session) => session.sessionId === lock.session_id);
|
||||
if (existingSession !== undefined) {
|
||||
return existingSession;
|
||||
}
|
||||
|
||||
return {
|
||||
sessionId: lock.session_id,
|
||||
runtime: lock.runtime,
|
||||
pid,
|
||||
startedAt: lock.started_at,
|
||||
milestoneId: lock.milestone_id,
|
||||
};
|
||||
}
|
||||
|
||||
async function buildStatusSummary(
|
||||
freshMission: Mission,
|
||||
tasks: MissionTask[],
|
||||
): Promise<MissionStatusSummary> {
|
||||
const done = tasks.filter((task) => task.status === 'done').length;
|
||||
const inProgress = tasks.filter((task) => task.status === 'in-progress').length;
|
||||
const pending = tasks.filter((task) => task.status === 'not-started').length;
|
||||
const blocked = tasks.filter((task) => task.status === 'blocked').length;
|
||||
const cancelled = tasks.filter((task) => task.status === 'cancelled').length;
|
||||
const nextTask = tasks.find((task) => task.status === 'not-started');
|
||||
|
||||
const completedMilestones = freshMission.milestones.filter(
|
||||
(milestone) => milestone.status === 'completed',
|
||||
).length;
|
||||
const currentMilestone =
|
||||
freshMission.milestones.find((milestone) => milestone.status === 'in-progress') ??
|
||||
freshMission.milestones.find((milestone) => milestone.status === 'pending');
|
||||
|
||||
const activeSession = await readActiveSession(freshMission);
|
||||
|
||||
return {
|
||||
mission: {
|
||||
id: freshMission.id,
|
||||
name: freshMission.name,
|
||||
status: freshMission.status,
|
||||
projectPath: freshMission.projectPath,
|
||||
},
|
||||
milestones: {
|
||||
total: freshMission.milestones.length,
|
||||
completed: completedMilestones,
|
||||
current: currentMilestone,
|
||||
},
|
||||
tasks: {
|
||||
total: tasks.length,
|
||||
done,
|
||||
inProgress,
|
||||
pending,
|
||||
blocked,
|
||||
cancelled,
|
||||
},
|
||||
nextTaskId: nextTask?.id,
|
||||
activeSession,
|
||||
};
|
||||
}
|
||||
|
||||
export async function getMissionStatus(mission: Mission): Promise<MissionStatusSummary> {
|
||||
const freshMission = await loadMission(mission.projectPath);
|
||||
const tasks = await readTasks(freshMission);
|
||||
return buildStatusSummary(freshMission, tasks);
|
||||
}
|
||||
|
||||
export async function getTaskStatus(mission: Mission, taskId: string): Promise<TaskDetail> {
|
||||
const freshMission = await loadMission(mission.projectPath);
|
||||
const tasks = await readTasks(freshMission);
|
||||
|
||||
const matches = tasks.filter((task) => task.id === taskId);
|
||||
if (matches.length === 0) {
|
||||
throw new Error(`Task not found: ${taskId}`);
|
||||
}
|
||||
|
||||
if (matches.length > 1) {
|
||||
throw new Error(`Duplicate task IDs found: ${taskId}`);
|
||||
}
|
||||
|
||||
const summary = await buildStatusSummary(freshMission, tasks);
|
||||
|
||||
return {
|
||||
missionId: freshMission.id,
|
||||
task: matches[0]!,
|
||||
isNextTask: summary.nextTaskId === taskId,
|
||||
activeSession: summary.activeSession,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,378 @@
|
||||
import { promises as fs } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
import type { Mission, MissionTask, TaskStatus } from './types.js';
|
||||
import { normalizeTaskStatus } from './types.js';
|
||||
|
||||
const TASKS_LOCK_FILE = '.TASKS.md.lock';
|
||||
const TASKS_LOCK_STALE_MS = 5 * 60 * 1000;
|
||||
const TASKS_LOCK_WAIT_MS = 5 * 1000;
|
||||
const TASKS_LOCK_RETRY_MS = 100;
|
||||
|
||||
const DEFAULT_TABLE_HEADER = [
|
||||
'| id | status | milestone | description | pr | notes |',
|
||||
'|----|--------|-----------|-------------|----|-------|',
|
||||
] as const;
|
||||
|
||||
const DEFAULT_TASKS_PREAMBLE = [
|
||||
'# Tasks',
|
||||
'',
|
||||
'> Single-writer: orchestrator only. Workers read but never modify.',
|
||||
'',
|
||||
...DEFAULT_TABLE_HEADER,
|
||||
] as const;
|
||||
|
||||
interface ParsedTableRow {
|
||||
readonly lineIndex: number;
|
||||
readonly cells: string[];
|
||||
}
|
||||
|
||||
interface ParsedTable {
|
||||
readonly headerLineIndex: number;
|
||||
readonly separatorLineIndex: number;
|
||||
readonly headers: string[];
|
||||
readonly rows: ParsedTableRow[];
|
||||
readonly idColumn: number;
|
||||
readonly statusColumn: number;
|
||||
}
|
||||
|
||||
function normalizeHeaderName(input: string): string {
|
||||
return input.trim().toLowerCase();
|
||||
}
|
||||
|
||||
function splitMarkdownRow(line: string): string[] {
|
||||
const trimmed = line.trim();
|
||||
if (!trimmed.startsWith('|')) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const parts = trimmed.split(/(?<!\\)\|/);
|
||||
if (parts.length < 3) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return parts.slice(1, -1).map((part) => part.trim().replace(/\\\|/g, '|'));
|
||||
}
|
||||
|
||||
function isSeparatorRow(cells: readonly string[]): boolean {
|
||||
return (
|
||||
cells.length > 0 &&
|
||||
cells.every((cell) => {
|
||||
const value = cell.trim();
|
||||
return /^:?-{3,}:?$/.test(value);
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
function parseTable(content: string): ParsedTable | undefined {
|
||||
const lines = content.split(/\r?\n/);
|
||||
|
||||
let headerLineIndex = -1;
|
||||
let separatorLineIndex = -1;
|
||||
let headers: string[] = [];
|
||||
|
||||
for (let index = 0; index < lines.length; index += 1) {
|
||||
const cells = splitMarkdownRow(lines[index] as string);
|
||||
if (cells.length === 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const normalized = cells.map(normalizeHeaderName);
|
||||
if (!normalized.includes('id') || !normalized.includes('status')) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (index + 1 >= lines.length) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const separatorCells = splitMarkdownRow(lines[index + 1] as string);
|
||||
if (!isSeparatorRow(separatorCells)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
headerLineIndex = index;
|
||||
separatorLineIndex = index + 1;
|
||||
headers = normalized;
|
||||
break;
|
||||
}
|
||||
|
||||
if (headerLineIndex < 0 || separatorLineIndex < 0) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const idColumn = headers.indexOf('id');
|
||||
const statusColumn = headers.indexOf('status');
|
||||
if (idColumn < 0 || statusColumn < 0) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const rows: ParsedTableRow[] = [];
|
||||
let sawData = false;
|
||||
|
||||
for (let index = separatorLineIndex + 1; index < lines.length; index += 1) {
|
||||
const rawLine = lines[index] as string;
|
||||
const trimmed = rawLine.trim();
|
||||
|
||||
if (!trimmed.startsWith('|')) {
|
||||
if (sawData) {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
const cells = splitMarkdownRow(rawLine);
|
||||
if (cells.length === 0) {
|
||||
if (sawData) {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
sawData = true;
|
||||
|
||||
const normalizedRow = [...cells];
|
||||
while (normalizedRow.length < headers.length) {
|
||||
normalizedRow.push('');
|
||||
}
|
||||
|
||||
rows.push({ lineIndex: index, cells: normalizedRow });
|
||||
}
|
||||
|
||||
return {
|
||||
headerLineIndex,
|
||||
separatorLineIndex,
|
||||
headers,
|
||||
rows,
|
||||
idColumn,
|
||||
statusColumn,
|
||||
};
|
||||
}
|
||||
|
||||
function escapeTableCell(value: string): string {
|
||||
return value.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ').trim();
|
||||
}
|
||||
|
||||
function formatTableRow(cells: readonly string[]): string {
|
||||
const escaped = cells.map((cell) => escapeTableCell(cell));
|
||||
return `| ${escaped.join(' | ')} |`;
|
||||
}
|
||||
|
||||
function parseDependencies(raw: string | undefined): string[] {
|
||||
if (raw === undefined || raw.trim().length === 0) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return raw
|
||||
.split(',')
|
||||
.map((value) => value.trim())
|
||||
.filter((value) => value.length > 0);
|
||||
}
|
||||
|
||||
function resolveTasksFilePath(mission: Mission): string {
|
||||
if (path.isAbsolute(mission.tasksFile)) {
|
||||
return mission.tasksFile;
|
||||
}
|
||||
|
||||
return path.join(mission.projectPath, mission.tasksFile);
|
||||
}
|
||||
|
||||
function isNodeErrorWithCode(error: unknown, code: string): boolean {
|
||||
return (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
(error as { code?: string }).code === code
|
||||
);
|
||||
}
|
||||
|
||||
async function delay(ms: number): Promise<void> {
|
||||
await new Promise((resolve) => {
|
||||
setTimeout(resolve, ms);
|
||||
});
|
||||
}
|
||||
|
||||
async function acquireLock(lockPath: string): Promise<void> {
|
||||
const startedAt = Date.now();
|
||||
|
||||
while (Date.now() - startedAt < TASKS_LOCK_WAIT_MS) {
|
||||
try {
|
||||
const handle = await fs.open(lockPath, 'wx');
|
||||
await handle.writeFile(
|
||||
JSON.stringify(
|
||||
{
|
||||
pid: process.pid,
|
||||
acquiredAt: new Date().toISOString(),
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
await handle.close();
|
||||
return;
|
||||
} catch (error) {
|
||||
if (!isNodeErrorWithCode(error, 'EEXIST')) {
|
||||
throw error;
|
||||
}
|
||||
|
||||
try {
|
||||
const stats = await fs.stat(lockPath);
|
||||
if (Date.now() - stats.mtimeMs > TASKS_LOCK_STALE_MS) {
|
||||
await fs.rm(lockPath, { force: true });
|
||||
await delay(TASKS_LOCK_RETRY_MS);
|
||||
continue;
|
||||
}
|
||||
} catch (statError) {
|
||||
if (!isNodeErrorWithCode(statError, 'ENOENT')) {
|
||||
throw statError;
|
||||
}
|
||||
}
|
||||
|
||||
await delay(TASKS_LOCK_RETRY_MS);
|
||||
}
|
||||
}
|
||||
|
||||
throw new Error(`Timed out acquiring TASKS lock: ${lockPath}`);
|
||||
}
|
||||
|
||||
async function releaseLock(lockPath: string): Promise<void> {
|
||||
await fs.rm(lockPath, { force: true });
|
||||
}
|
||||
|
||||
async function writeAtomic(filePath: string, content: string): Promise<void> {
|
||||
const directory = path.dirname(filePath);
|
||||
await fs.mkdir(directory, { recursive: true });
|
||||
const tempPath = path.join(
|
||||
directory,
|
||||
`.TASKS.md.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
|
||||
);
|
||||
|
||||
await fs.writeFile(tempPath, content, 'utf8');
|
||||
await fs.rename(tempPath, filePath);
|
||||
}
|
||||
|
||||
export function parseTasksFile(content: string): MissionTask[] {
|
||||
const parsedTable = parseTable(content);
|
||||
if (parsedTable === undefined) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const headerToColumn = new Map<string, number>();
|
||||
parsedTable.headers.forEach((header, index) => {
|
||||
headerToColumn.set(header, index);
|
||||
});
|
||||
|
||||
const descriptionColumn = headerToColumn.get('description') ?? headerToColumn.get('title') ?? -1;
|
||||
const milestoneColumn = headerToColumn.get('milestone') ?? -1;
|
||||
const prColumn = headerToColumn.get('pr') ?? -1;
|
||||
const notesColumn = headerToColumn.get('notes') ?? -1;
|
||||
const assigneeColumn = headerToColumn.get('assignee') ?? -1;
|
||||
const dependenciesColumn = headerToColumn.get('dependencies') ?? -1;
|
||||
|
||||
const tasks: MissionTask[] = [];
|
||||
|
||||
for (const row of parsedTable.rows) {
|
||||
const id = row.cells[parsedTable.idColumn]?.trim();
|
||||
if (id === undefined || id.length === 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const rawStatusValue = row.cells[parsedTable.statusColumn] ?? '';
|
||||
const normalized = normalizeTaskStatus(rawStatusValue);
|
||||
|
||||
const title = descriptionColumn >= 0 ? (row.cells[descriptionColumn] ?? '') : '';
|
||||
const milestone = milestoneColumn >= 0 ? (row.cells[milestoneColumn] ?? '') : '';
|
||||
const pr = prColumn >= 0 ? (row.cells[prColumn] ?? '') : '';
|
||||
const notes = notesColumn >= 0 ? (row.cells[notesColumn] ?? '') : '';
|
||||
const assignee = assigneeColumn >= 0 ? (row.cells[assigneeColumn] ?? '') : '';
|
||||
const dependenciesRaw = dependenciesColumn >= 0 ? (row.cells[dependenciesColumn] ?? '') : '';
|
||||
|
||||
tasks.push({
|
||||
id,
|
||||
title,
|
||||
status: normalized.status,
|
||||
dependencies: parseDependencies(dependenciesRaw),
|
||||
milestone: milestone.length > 0 ? milestone : undefined,
|
||||
pr: pr.length > 0 ? pr : undefined,
|
||||
notes: notes.length > 0 ? notes : undefined,
|
||||
assignee: assignee.length > 0 ? assignee : undefined,
|
||||
rawStatus: normalized.rawStatus,
|
||||
line: row.lineIndex + 1,
|
||||
});
|
||||
}
|
||||
|
||||
return tasks;
|
||||
}
|
||||
|
||||
export function writeTasksFile(tasks: MissionTask[]): string {
|
||||
const lines: string[] = [...DEFAULT_TASKS_PREAMBLE];
|
||||
|
||||
for (const task of tasks) {
|
||||
lines.push(
|
||||
formatTableRow([
|
||||
task.id,
|
||||
task.status,
|
||||
task.milestone ?? '',
|
||||
task.title,
|
||||
task.pr ?? '',
|
||||
task.notes ?? '',
|
||||
]),
|
||||
);
|
||||
}
|
||||
|
||||
return `${lines.join('\n')}\n`;
|
||||
}
|
||||
|
||||
export async function updateTaskStatus(
|
||||
mission: Mission,
|
||||
taskId: string,
|
||||
status: TaskStatus,
|
||||
): Promise<void> {
|
||||
const tasksFilePath = resolveTasksFilePath(mission);
|
||||
const lockPath = path.join(path.dirname(tasksFilePath), TASKS_LOCK_FILE);
|
||||
|
||||
await fs.mkdir(path.dirname(tasksFilePath), { recursive: true });
|
||||
await acquireLock(lockPath);
|
||||
|
||||
try {
|
||||
let content: string;
|
||||
try {
|
||||
content = await fs.readFile(tasksFilePath, 'utf8');
|
||||
} catch (error) {
|
||||
if (isNodeErrorWithCode(error, 'ENOENT')) {
|
||||
throw new Error(`TASKS file not found: ${tasksFilePath}`);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
|
||||
const table = parseTable(content);
|
||||
if (table === undefined) {
|
||||
throw new Error(`Could not parse TASKS table in ${tasksFilePath}`);
|
||||
}
|
||||
|
||||
const matchingRows = table.rows.filter((row) => {
|
||||
const rowTaskId = row.cells[table.idColumn]?.trim();
|
||||
return rowTaskId === taskId;
|
||||
});
|
||||
|
||||
if (matchingRows.length === 0) {
|
||||
throw new Error(`Task not found in TASKS.md: ${taskId}`);
|
||||
}
|
||||
|
||||
if (matchingRows.length > 1) {
|
||||
throw new Error(`Duplicate task IDs found in TASKS.md: ${taskId}`);
|
||||
}
|
||||
|
||||
const targetRow = matchingRows[0] as ParsedTableRow;
|
||||
const updatedCells = [...targetRow.cells];
|
||||
updatedCells[table.statusColumn] = status;
|
||||
|
||||
const lines = content.split(/\r?\n/);
|
||||
lines[targetRow.lineIndex] = formatTableRow(updatedCells);
|
||||
|
||||
const updatedContent = `${lines.join('\n').replace(/\n+$/, '')}\n`;
|
||||
await writeAtomic(tasksFilePath, updatedContent);
|
||||
} finally {
|
||||
await releaseLock(lockPath);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
export type TaskStatus = 'not-started' | 'in-progress' | 'done' | 'blocked' | 'cancelled';
|
||||
|
||||
export type MissionStatus = 'active' | 'paused' | 'completed' | 'inactive';
|
||||
|
||||
export type MissionRuntime = 'claude' | 'codex' | 'unknown';
|
||||
|
||||
export interface MissionMilestone {
|
||||
id: string;
|
||||
name: string;
|
||||
status: 'pending' | 'in-progress' | 'completed' | 'blocked';
|
||||
branch?: string;
|
||||
issueRef?: string;
|
||||
startedAt?: string;
|
||||
completedAt?: string;
|
||||
}
|
||||
|
||||
export interface MissionSession {
|
||||
sessionId: string;
|
||||
runtime: MissionRuntime;
|
||||
pid?: number;
|
||||
startedAt: string;
|
||||
endedAt?: string;
|
||||
endedReason?: 'completed' | 'paused' | 'crashed' | 'killed' | 'unknown';
|
||||
milestoneId?: string;
|
||||
lastTaskId?: string;
|
||||
durationSeconds?: number;
|
||||
}
|
||||
|
||||
export interface Mission {
|
||||
schemaVersion: 1;
|
||||
id: string;
|
||||
name: string;
|
||||
description?: string;
|
||||
projectPath: string;
|
||||
createdAt: string;
|
||||
status: MissionStatus;
|
||||
tasksFile: string;
|
||||
manifestFile: string;
|
||||
scratchpadFile: string;
|
||||
orchestratorDir: string;
|
||||
taskPrefix?: string;
|
||||
qualityGates?: string;
|
||||
milestoneVersion?: string;
|
||||
milestones: MissionMilestone[];
|
||||
sessions: MissionSession[];
|
||||
}
|
||||
|
||||
export interface MissionTask {
|
||||
id: string;
|
||||
title: string;
|
||||
status: TaskStatus;
|
||||
assignee?: string;
|
||||
dependencies: string[];
|
||||
milestone?: string;
|
||||
pr?: string;
|
||||
notes?: string;
|
||||
rawStatus?: string;
|
||||
line?: number;
|
||||
}
|
||||
|
||||
export interface TaskRun {
|
||||
missionId: string;
|
||||
taskId: string;
|
||||
sessionId: string;
|
||||
runtime: 'claude' | 'codex';
|
||||
launchCommand: string[];
|
||||
startedAt: string;
|
||||
pid?: number;
|
||||
lockFile: string;
|
||||
}
|
||||
|
||||
export interface MissionStatusSummary {
|
||||
mission: Pick<Mission, 'id' | 'name' | 'status' | 'projectPath'>;
|
||||
milestones: {
|
||||
total: number;
|
||||
completed: number;
|
||||
current?: MissionMilestone;
|
||||
};
|
||||
tasks: {
|
||||
total: number;
|
||||
done: number;
|
||||
inProgress: number;
|
||||
pending: number;
|
||||
blocked: number;
|
||||
cancelled: number;
|
||||
};
|
||||
nextTaskId?: string;
|
||||
activeSession?: MissionSession;
|
||||
}
|
||||
|
||||
export interface TaskDetail {
|
||||
missionId: string;
|
||||
task: MissionTask;
|
||||
isNextTask: boolean;
|
||||
activeSession?: MissionSession;
|
||||
}
|
||||
|
||||
export interface CreateMissionOptions {
|
||||
name: string;
|
||||
projectPath?: string;
|
||||
prefix?: string;
|
||||
milestones?: string[];
|
||||
qualityGates?: string;
|
||||
version?: string;
|
||||
description?: string;
|
||||
force?: boolean;
|
||||
}
|
||||
|
||||
export interface RunTaskOptions {
|
||||
runtime?: 'claude' | 'codex';
|
||||
mode?: 'interactive' | 'print-only';
|
||||
milestoneId?: string;
|
||||
launchStrategy?: 'subprocess' | 'spawn-adapter';
|
||||
env?: Record<string, string>;
|
||||
command?: string[];
|
||||
}
|
||||
|
||||
export interface NextTaskCapsule {
|
||||
generatedAt: string;
|
||||
runtime: 'claude' | 'codex';
|
||||
missionId: string;
|
||||
missionName: string;
|
||||
projectPath: string;
|
||||
qualityGates?: string;
|
||||
currentMilestone: {
|
||||
id?: string;
|
||||
name?: string;
|
||||
};
|
||||
nextTask: string;
|
||||
progress: {
|
||||
tasksDone: number;
|
||||
tasksTotal: number;
|
||||
pct: number;
|
||||
};
|
||||
currentBranch?: string;
|
||||
}
|
||||
|
||||
const LEGACY_TASK_STATUS: Readonly<Record<string, TaskStatus>> = {
|
||||
'not-started': 'not-started',
|
||||
pending: 'not-started',
|
||||
todo: 'not-started',
|
||||
'in-progress': 'in-progress',
|
||||
in_progress: 'in-progress',
|
||||
done: 'done',
|
||||
completed: 'done',
|
||||
blocked: 'blocked',
|
||||
failed: 'blocked',
|
||||
cancelled: 'cancelled',
|
||||
};
|
||||
|
||||
export function normalizeTaskStatus(input: string): {
|
||||
status: TaskStatus;
|
||||
rawStatus?: string;
|
||||
} {
|
||||
const raw = input.trim().toLowerCase();
|
||||
if (raw.length === 0) {
|
||||
return { status: 'not-started' };
|
||||
}
|
||||
|
||||
const normalized = LEGACY_TASK_STATUS[raw];
|
||||
if (normalized === undefined) {
|
||||
return { status: 'not-started', rawStatus: raw };
|
||||
}
|
||||
|
||||
if (raw !== normalized) {
|
||||
return { status: normalized, rawStatus: raw };
|
||||
}
|
||||
|
||||
return { status: normalized };
|
||||
}
|
||||
|
||||
export function isMissionStatus(value: string): value is MissionStatus {
|
||||
return value === 'active' || value === 'paused' || value === 'completed' || value === 'inactive';
|
||||
}
|
||||
|
||||
export function isTaskStatus(value: string): value is TaskStatus {
|
||||
return (
|
||||
value === 'not-started' ||
|
||||
value === 'in-progress' ||
|
||||
value === 'done' ||
|
||||
value === 'blocked' ||
|
||||
value === 'cancelled'
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"extends": "../../tsconfig.base.json",
|
||||
"compilerOptions": {
|
||||
"outDir": "dist",
|
||||
"rootDir": "src"
|
||||
},
|
||||
"include": ["src/**/*"],
|
||||
"exclude": ["node_modules", "dist"]
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
import { defineConfig } from 'vitest/config';
|
||||
|
||||
export default defineConfig({
|
||||
test: {
|
||||
globals: true,
|
||||
environment: 'node',
|
||||
},
|
||||
});
|
||||
Reference in New Issue
Block a user