claude-flow 3.50.0 → 3.51.0

package/v3/@claude-flow/cli/dist/src/mcp-client.js

@@ -72,6 +72,7 @@ import { businessPodTools } from './mcp-tools/business-pod-tools.js';
 // for ops-pod synthetic-endpoint benches). Default-rejects private addresses
 // + auth headers; opt-in via CLAUDE_FLOW_HTTP_FETCH_ALLOW_PRIVATE / _AUTH=1.
 import { httpFetchTools } from './mcp-tools/http-fetch-tools.js';
+import { missionTools } from './mcp-tools/mission-tools.js';
 // #1916: coverage-aware routing tools — defined in ruvector/coverage-tools.ts
 // but were never registered, so the `ruflo hooks coverage-*` CLI subcommands
 // failed with `Tool not found: hooks_coverage-route`.
@@ -180,6 +181,8 @@ registerTools([
     ...businessPodTools,
     // ADR-164 Phase 4 §5.1.8 — http_fetch (1 tool, secure-by-default HTTP probe)
     ...httpFetchTools,
+    // ADR-406 — mission semantic operations (create/plan/get/events/request_action)
+    ...missionTools,
 ]);
 // The capability brain consumes the completed live registry. This is injected
 // after registration to keep guidance honest and avoid a registry import cycle.

package/v3/@claude-flow/cli/dist/src/mcp-tools/capability-brain.js

@@ -314,7 +314,7 @@ export const CAPABILITY_DOMAINS = [
     {
         id: 'tasks-workflows-sessions',
         name: 'Tasks, Workflows, Sessions & Progress',
-        prefixes: ['task_', 'workflow_', 'session_', 'progress_'],
+        prefixes: ['task_', 'workflow_', 'session_', 'progress_', 'mission_'],
         description: 'Task orchestration, reusable workflows, session state, progress, and handoff.',
         taskSignals: ['task', 'workflow', 'session', 'handoff', 'progress'],
         commands: ['task create', 'task status', 'workflow run'],

package/v3/@claude-flow/cli/dist/src/mcp-tools/index.d.ts

@@ -38,4 +38,5 @@ export { xFederationJoinTools } from './x-federation-join.js';
 export { xFederationChannelTools } from './x-federation-channels.js';
 export { businessPodTools } from './business-pod-tools.js';
 export { httpFetchTools } from './http-fetch-tools.js';
+export { missionTools, createMissionTools } from './mission-tools.js';
 //# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/index.js

@@ -43,4 +43,6 @@ export { xFederationChannelTools } from './x-federation-channels.js';
 export { businessPodTools } from './business-pod-tools.js';
 // ADR-164 Phase 4 §5.1.8 — http_fetch (secure-by-default HTTP probe)
 export { httpFetchTools } from './http-fetch-tools.js';
+// ADR-406 — mission semantic operations
+export { missionTools, createMissionTools } from './mission-tools.js';
 //# sourceMappingURL=index.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/mission-tools.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ADR-406 §19.7 — MCP adapter for the mission semantic operations.
+ *
+ * A thin transport: input goes to the same `MissionService` (and the same zod
+ * schemas) the CLI uses, unchanged. Policy authorization of the tool call
+ * itself happens in `mcp-client.ts` before any handler runs; nothing here
+ * accepts an approval, principal or permission flag from input.
+ */
+import type { MCPTool } from './types.js';
+import { type MissionResult } from '../missions/service.js';
+/** The operations an adapter needs; London-school tests substitute it. */
+export interface MissionPort {
+    create(raw: unknown): Promise<MissionResult<unknown>>;
+    plan(raw: unknown): Promise<MissionResult<unknown>>;
+    get(raw: unknown): Promise<MissionResult<unknown>>;
+    events(raw: unknown): Promise<MissionResult<unknown>>;
+    requestAction(raw: unknown): Promise<MissionResult<unknown>>;
+}
+export type MissionPortFactory = (projectRoot: string) => MissionPort;
+export declare function createMissionTools(factory?: MissionPortFactory): MCPTool[];
+export declare const missionTools: MCPTool[];
+//# sourceMappingURL=mission-tools.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/mission-tools.js

@@ -0,0 +1,75 @@
+/**
+ * ADR-406 §19.7 — MCP adapter for the mission semantic operations.
+ *
+ * A thin transport: input goes to the same `MissionService` (and the same zod
+ * schemas) the CLI uses, unchanged. Policy authorization of the tool call
+ * itself happens in `mcp-client.ts` before any handler runs; nothing here
+ * accepts an approval, principal or permission flag from input.
+ */
+import { getProjectCwd } from './types.js';
+import { MissionService } from '../missions/service.js';
+const defaultFactory = (projectRoot) => new MissionService({ projectRoot, channel: 'mcp' });
+function rootOf(context) {
+    return typeof context?.projectRoot === 'string' ? context.projectRoot : getProjectCwd();
+}
+const MISSION_ID = { type: 'string', pattern: '^msn_[a-f0-9]{24}$', description: 'Mission id' };
+const REQUEST_ID = { type: 'string', maxLength: 128, description: 'Caller-chosen idempotency key; reuse only to retry the same request' };
+const EXPECTED_REVISION = { type: 'integer', minimum: 1, description: 'Mission revision the request was prepared against' };
+export function createMissionTools(factory = defaultFactory) {
+    const call = (op) => async (input, context) => factory(rootOf(context))[op](input);
+    return [
+        {
+            name: 'mission_create',
+            description: 'Create a draft mission (objective only), idempotent per requestId. Use when starting governed multi-step work that several clients (CLI, MCP, the Claude Code workbench) must observe and control through one durable record. task_create is wrong because a task has no plan revision, budget ceiling or acceptance evidence. Recording a mission executes nothing.',
+            category: 'mission',
+            inputSchema: { type: 'object', properties: { requestId: REQUEST_ID, objective: { type: 'string', maxLength: 2000 } }, required: ['requestId', 'objective'] },
+            handler: call('create'),
+        },
+        {
+            name: 'mission_plan',
+            description: 'Submit or revise a mission plan: acyclic task graph, acceptance criteria and budget ceiling in integer minor units. Use when a mission needs a reviewable plan before any authorization or admission. Editing plan state through memory_store is wrong because it bypasses revision checks: a stale expectedRevision here returns a conflict with the current revision, and a revision invalidates prior authorization.',
+            category: 'mission',
+            inputSchema: {
+                type: 'object',
+                properties: { requestId: REQUEST_ID, missionId: MISSION_ID, expectedRevision: EXPECTED_REVISION, plan: { type: 'object', description: '{ tasks[], acceptance[], budget{currency, ceilingMinor}, scope }' } },
+                required: ['requestId', 'missionId', 'expectedRevision', 'plan'],
+            },
+            handler: call('plan'),
+        },
+        {
+            name: 'mission_get',
+            description: 'Read one mission (record, plan, budget, tasks, evidence, executor observation) or list missions; read only. Use when you need the authoritative current state of a mission before acting on it. Inferring state from task_status or a UI badge is wrong because task status is recorded state; only evidence.verified counts as verified, and a disconnected executor is not a failure.',
+            category: 'mission',
+            inputSchema: { type: 'object', properties: { missionId: MISSION_ID } },
+            handler: call('get'),
+        },
+        {
+            name: 'mission_events',
+            description: 'Read mission events after a durable cursor (afterSequence). Use when resuming or reconnecting a client and you need exactly what changed since your last sequence. Re-reading mission_get in a loop is wrong because it loses the transition history; delivery here may repeat, so deduplicate by (missionId, seq), and gap=true means reload with mission_get before replaying.',
+            category: 'mission',
+            inputSchema: {
+                type: 'object',
+                properties: { missionId: MISSION_ID, afterSequence: { type: 'integer', minimum: 0 }, limit: { type: 'integer', minimum: 1, maximum: 500 } },
+                required: ['missionId'],
+            },
+            handler: call('events'),
+        },
+        {
+            name: 'mission_request_action',
+            description: 'Request a scoped mission control action: requestAuthorization, pause or cancel (admit and resume report executor-unavailable until a durable executor is admitted). Use when a person or agent wants a running or planned mission to change course. Calling task_cancel or killing a process is wrong because it skips the revision check and executor acknowledgement; a request is not authorization, the runtime decides.',
+            category: 'mission',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    requestId: REQUEST_ID, missionId: MISSION_ID, expectedRevision: EXPECTED_REVISION,
+                    action: { type: 'string', enum: ['requestAuthorization', 'pause', 'cancel', 'admit', 'resume'] },
+                    reason: { type: 'string', maxLength: 500 },
+                },
+                required: ['requestId', 'missionId', 'expectedRevision', 'action'],
+            },
+            handler: call('requestAction'),
+        },
+    ];
+}
+export const missionTools = createMissionTools();
+//# sourceMappingURL=mission-tools.js.map

package/v3/@claude-flow/cli/dist/src/missions/fold.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ADR-406 §19.3 — fold a mission's append-only event log into a `MissionView`.
+ *
+ * Replay re-checks every control event against the transition table and every
+ * observation against its own rules, and verifies the hash chain, so state is
+ * a pure function of the log: snapshot + tail and full replay must agree.
+ */
+import { type ControlEventType, type MissionEvent, type ObservationEventType } from './schemas.js';
+import { type MissionView } from './transitions.js';
+export declare const GENESIS_HASH: string;
+export declare function isControlEvent(type: string): type is ControlEventType;
+/** Hash over every field except `hash` itself, chained through `prevHash`. */
+export declare function eventHash(event: Omit<MissionEvent, 'hash'>): string;
+/** Observation rules; throws `TransitionError`. Observations never change state. */
+export declare function checkObservation(view: MissionView, type: ObservationEventType, p: Record<string, unknown>): void;
+/** Apply one event; throws `TransitionError` for anything the rules refuse. */
+export declare function foldEvent(view: MissionView | null, event: MissionEvent): MissionView;
+export declare function replay(events: readonly MissionEvent[], from?: MissionView | null): MissionView | null;
+//# sourceMappingURL=fold.d.ts.map

package/v3/@claude-flow/cli/dist/src/missions/fold.js

@@ -0,0 +1,238 @@
+/**
+ * ADR-406 §19.3 — fold a mission's append-only event log into a `MissionView`.
+ *
+ * Replay re-checks every control event against the transition table and every
+ * observation against its own rules, and verifies the hash chain, so state is
+ * a pure function of the log: snapshot + tail and full replay must agree.
+ */
+import { createHash } from 'node:crypto';
+import { canonicalJson } from '../mods/command-registry/catalog.js';
+import { CONTROL_EVENTS, MISSION_EVENT_CONTRACT, MISSION_SCHEMA_VERSION, executorConnectionSchema, missionRecordSchema, } from './schemas.js';
+import { TransitionError, checkTransition, digestOf } from './transitions.js';
+import { TERMINAL_STATES } from './schemas.js';
+export const GENESIS_HASH = `sha256:${'0'.repeat(64)}`;
+const TASK_STATUSES = new Set(['pending', 'running', 'recorded-done', 'failed', 'unknown']);
+export function isControlEvent(type) {
+    return CONTROL_EVENTS.includes(type);
+}
+/** Hash over every field except `hash` itself, chained through `prevHash`. */
+export function eventHash(event) {
+    return `sha256:${createHash('sha256').update(canonicalJson(event)).digest('hex')}`;
+}
+/** Observation rules; throws `TransitionError`. Observations never change state. */
+export function checkObservation(view, type, p) {
+    if (TERMINAL_STATES.has(view.record.state))
+        throw new TransitionError('terminal', `mission is ${view.record.state}`);
+    if (type === 'executor.observed') {
+        if (typeof p.executorId !== 'string' || !p.executorId)
+            throw new TransitionError('invalid-observation', 'executorId required');
+        if (!executorConnectionSchema.safeParse(p.connection).success)
+            throw new TransitionError('invalid-observation', 'connection must be healthy|stale|disconnected|unknown');
+        if (typeof p.observedAt !== 'string')
+            throw new TransitionError('invalid-observation', 'observedAt (source time) required');
+        return;
+    }
+    if (type === 'task.observed') {
+        if (!view.planBody?.tasks.some((t) => t.id === p.taskId))
+            throw new TransitionError('invalid-observation', `unknown task ${String(p.taskId)}`);
+        if (!TASK_STATUSES.has(p.status))
+            throw new TransitionError('invalid-observation', 'invalid task status');
+        if (p.leaseEpoch !== view.lease.epoch)
+            throw new TransitionError('stale-epoch', `lease epoch ${String(p.leaseEpoch)} is not current (${view.lease.epoch})`);
+        return;
+    }
+    // evidence.recorded
+    if (!view.planBody?.acceptance.some((c) => c.id === p.criterionId))
+        throw new TransitionError('invalid-observation', `unknown criterion ${String(p.criterionId)}`);
+    if (typeof p.evidenceId !== 'string' || typeof p.producer !== 'string')
+        throw new TransitionError('invalid-observation', 'evidenceId and producer required');
+    if (typeof p.artifactDigest !== 'string' || !/^sha256:[a-f0-9]{64}$/.test(p.artifactDigest))
+        throw new TransitionError('invalid-observation', 'artifactDigest required');
+    if (typeof p.verified !== 'boolean')
+        throw new TransitionError('invalid-observation', 'verified flag required');
+    if (view.evidence.some((e) => e.evidenceId === p.evidenceId))
+        throw new TransitionError('invalid-observation', `duplicate evidence ${String(p.evidenceId)}`);
+}
+function created(event) {
+    const p = event.payload;
+    const record = missionRecordSchema.parse({
+        schemaVersion: MISSION_SCHEMA_VERSION,
+        missionId: event.missionId,
+        tenantId: p.tenantId,
+        workspaceId: p.workspaceId,
+        ownerPrincipalId: p.ownerPrincipalId,
+        revision: 1,
+        objective: p.objective,
+        plan: { revision: 0, digest: 'none', taskGraphRef: 'none' },
+        policyRef: p.policyRef,
+        budgetRef: p.budgetRef,
+        executionMode: 'session-bound',
+        state: 'draft',
+        evidenceRefs: [],
+        acceptance: { revision: 0, criteriaDigest: 'none' },
+        lastEventSequence: event.seq,
+        createdAt: event.at,
+        updatedAt: event.at,
+    });
+    return {
+        record, planBody: null, budget: null, tasks: {}, evidence: [], executor: null,
+        lease: { executorId: null, epoch: 0 }, unresolvedOperations: [], blockedReason: null, lastHash: event.hash,
+    };
+}
+function withPlan(view, plan, event) {
+    const criteriaDigest = digestOf(plan.acceptance);
+    const prior = view.record.acceptance;
+    const estimated = plan.tasks.reduce((s, t) => s + t.estimatedCostMinor, 0);
+    const tasks = {};
+    for (const t of plan.tasks)
+        tasks[t.id] = { status: view.tasks[t.id]?.status ?? 'pending' };
+    return {
+        ...view,
+        planBody: plan,
+        tasks,
+        budget: {
+            currency: plan.budget.currency,
+            ceilingMinor: plan.budget.ceilingMinor,
+            estimatedMinor: estimated,
+            reservedMinor: view.budget?.reservedMinor ?? 0,
+            settledMinor: view.budget?.settledMinor ?? 0,
+            unresolvedMinor: view.budget?.unresolvedMinor ?? 0,
+        },
+        record: {
+            ...view.record,
+            plan: { revision: view.record.plan.revision + 1, digest: String(event.payload.digest), taskGraphRef: `event:${event.seq}` },
+            acceptance: { revision: criteriaDigest === prior.criteriaDigest ? prior.revision : prior.revision + 1, criteriaDigest },
+            executionMode: plan.tasks.some((t) => t.executor.mode === 'session-bound') ? 'session-bound' : 'durable-executor',
+            // §19.4: a new plan revision invalidates authorization for the old one.
+            authorizationRef: undefined,
+        },
+    };
+}
+function applyControl(view, event) {
+    const rule = checkTransition(view, event.type, event.payload);
+    if (event.revision !== view.record.revision + 1) {
+        throw new TransitionError('revision-mismatch', `control event ${event.seq} must advance revision to ${view.record.revision + 1}`);
+    }
+    if (event.expectedRevision !== view.record.revision) {
+        throw new TransitionError('revision-conflict', `expected ${String(event.expectedRevision)}, current ${view.record.revision}`);
+    }
+    let next = view;
+    const p = event.payload;
+    switch (event.type) {
+        case 'plan.validated':
+        case 'plan.revised':
+            next = withPlan(view, p.plan, event);
+            break;
+        case 'admission.accepted':
+        case 'resume.admitted':
+            next = {
+                ...view,
+                budget: view.budget && { ...view.budget, reservedMinor: view.budget.reservedMinor + Number(p.reservationMinor) },
+                // A new admission fences every executor holding an older epoch.
+                lease: { executorId: null, epoch: view.lease.epoch + 1 },
+                blockedReason: null,
+                record: { ...view.record, authorizationRef: String(p.authorizationRef) },
+            };
+            break;
+        case 'executor.acknowledged':
+            next = { ...view, lease: { executorId: String(p.executorId), epoch: view.lease.epoch } };
+            break;
+        case 'blocked':
+            next = { ...view, blockedReason: String(p.reason) };
+            break;
+        default:
+            break;
+    }
+    const record = { ...next.record };
+    if (record.authorizationRef === undefined)
+        delete record.authorizationRef;
+    return {
+        ...next,
+        record: { ...record, state: rule.to, revision: view.record.revision + 1, lastEventSequence: event.seq, updatedAt: event.at },
+        lastHash: event.hash,
+    };
+}
+function applyObservation(view, event) {
+    checkObservation(view, event.type, event.payload);
+    const p = event.payload;
+    let next = view;
+    if (event.type === 'executor.observed') {
+        next = {
+            ...view,
+            executor: {
+                executorId: String(p.executorId),
+                connection: String(p.connection),
+                observedAt: String(p.observedAt),
+                lastAckExecutionId: typeof p.lastAckExecutionId === 'string' ? p.lastAckExecutionId : view.executor?.lastAckExecutionId ?? null,
+            },
+        };
+    }
+    else if (event.type === 'task.observed') {
+        const id = String(p.taskId);
+        const status = p.status;
+        const op = `task:${id}`;
+        const unresolved = view.unresolvedOperations.filter((o) => o !== op);
+        next = {
+            ...view,
+            tasks: { ...view.tasks, [id]: { status, ...(typeof p.invocationId === 'string' ? { invocationId: p.invocationId } : {}) } },
+            // An unknown outcome stays unresolved until a later observation settles it.
+            unresolvedOperations: status === 'unknown' ? [...unresolved, op] : unresolved,
+        };
+    }
+    else {
+        next = {
+            ...view,
+            evidence: [...view.evidence, {
+                    evidenceId: String(p.evidenceId),
+                    criterionId: String(p.criterionId),
+                    taskId: typeof p.taskId === 'string' ? p.taskId : null,
+                    artifactDigest: String(p.artifactDigest),
+                    producer: String(p.producer),
+                    verified: p.verified === true,
+                    planRevision: view.record.plan.revision,
+                    criteriaDigest: view.record.acceptance.criteriaDigest,
+                    at: event.at,
+                }],
+            record: { ...view.record, evidenceRefs: [...view.record.evidenceRefs, String(p.evidenceId)] },
+        };
+    }
+    return {
+        ...next,
+        record: { ...next.record, lastEventSequence: event.seq, updatedAt: event.at },
+        lastHash: event.hash,
+    };
+}
+/** Apply one event; throws `TransitionError` for anything the rules refuse. */
+export function foldEvent(view, event) {
+    if (event.contract !== MISSION_EVENT_CONTRACT)
+        throw new TransitionError('bad-contract', `unknown event contract ${String(event.contract)}`);
+    const expectedPrev = view ? view.lastHash : GENESIS_HASH;
+    if (event.prevHash !== expectedPrev)
+        throw new TransitionError('chain-broken', `event ${event.seq} prevHash mismatch`);
+    const { hash, ...rest } = event;
+    if (eventHash(rest) !== hash)
+        throw new TransitionError('chain-broken', `event ${event.seq} hash mismatch`);
+    const expectedSeq = view ? view.record.lastEventSequence + 1 : 1;
+    if (event.seq !== expectedSeq)
+        throw new TransitionError('sequence-gap', `event ${event.seq}, expected ${expectedSeq}`);
+    if (!view) {
+        if (event.type !== 'mission.created')
+            throw new TransitionError('invalid-transition', 'first event must be mission.created');
+        return created(event);
+    }
+    if (event.type === 'mission.created')
+        throw new TransitionError('invalid-transition', 'mission already created');
+    if (isControlEvent(event.type))
+        return applyControl(view, event);
+    if (event.expectedRevision !== null || event.revision !== view.record.revision) {
+        throw new TransitionError('invalid-observation', 'observations carry no expected revision and do not change it');
+    }
+    return applyObservation(view, event);
+}
+export function replay(events, from = null) {
+    let view = from;
+    for (const e of events)
+        view = foldEvent(view, e);
+    return view;
+}
+//# sourceMappingURL=fold.js.map

package/v3/@claude-flow/cli/dist/src/missions/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ADR-406 mission control runtime (M0 contract + storage, M1 observation).
+ */
+export * from './schemas.js';
+export * from './transitions.js';
+export * from './fold.js';
+export * from './store.js';
+export * from './observation.js';
+export * from './service.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/cli/dist/src/missions/index.js

@@ -0,0 +1,10 @@
+/**
+ * ADR-406 mission control runtime (M0 contract + storage, M1 observation).
+ */
+export * from './schemas.js';
+export * from './transitions.js';
+export * from './fold.js';
+export * from './store.js';
+export * from './observation.js';
+export * from './service.js';
+//# sourceMappingURL=index.js.map

package/v3/@claude-flow/cli/dist/src/missions/observation.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ADR-406 M1 / §11 — the bounded mission observation file a workbench reads.
+ *
+ * `.claude-flow/missions/observation.json` is rewritten atomically after each
+ * committed mission event. It carries the source time (`observedAt`, the time
+ * of the newest committed event); readers stamp their own fetch time and derive
+ * freshness from `observedAt`, never from a redraw. Strings are stripped of
+ * control and bidi characters and truncated here, at write time, so a reader
+ * never sees unbounded or instruction-shaped text from a mission.
+ *
+ * It is observation only. Task status is recorded state; only
+ * `evidence.verified` counts as verified, and an executor marked disconnected
+ * is not a failed mission.
+ */
+import type { MissionView } from './transitions.js';
+export declare const OBSERVATION_CONTRACT: "ruflo.mission-observation/1";
+export declare const OBSERVATION_FILE = "observation.json";
+export declare const OBSERVATION_LIMITS: Readonly<{
+    missions: 50;
+    tasks: 50;
+    string: 200;
+    objective: 400;
+}>;
+export interface MissionObservation {
+    readonly schemaVersion: 1;
+    readonly contract: typeof OBSERVATION_CONTRACT;
+    readonly source: 'ruflo-cli/missions';
+    readonly workspaceId: string;
+    readonly observedAt: string | null;
+    readonly truncated: boolean;
+    readonly missions: readonly ObservedMission[];
+}
+export interface ObservedMission {
+    readonly missionId: string;
+    readonly objective: string;
+    readonly state: string;
+    readonly revision: number;
+    readonly executionMode: string;
+    readonly plan: {
+        readonly revision: number;
+        readonly digest: string;
+        readonly taskCount: number;
+        readonly tasks: readonly {
+            readonly id: string;
+            readonly title: string;
+            readonly dependsOn: readonly string[];
+            readonly status: string;
+        }[];
+    };
+    readonly budget: MissionView['budget'];
+    readonly evidence: {
+        readonly count: number;
+        readonly verified: number;
+    };
+    readonly executor: {
+        readonly connection: string;
+        readonly observedAt: string;
+        readonly lastAckExecutionId: string | null;
+    } | null;
+    readonly unresolvedOperations: number;
+    readonly blockedReason: string | null;
+    readonly lastEventSequence: number;
+    readonly updatedAt: string;
+}
+/** Strip C0/C1 controls and bidi overrides, then bound the length. */
+export declare function sanitize(value: string, max?: number): string;
+export declare function observeMission(view: MissionView): ObservedMission;
+/** Newest-updated first, capped; `observedAt` is the newest committed event time. */
+export declare function buildObservation(workspaceId: string, views: readonly MissionView[]): MissionObservation;
+//# sourceMappingURL=observation.d.ts.map

package/v3/@claude-flow/cli/dist/src/missions/observation.js

@@ -0,0 +1,77 @@
+/**
+ * ADR-406 M1 / §11 — the bounded mission observation file a workbench reads.
+ *
+ * `.claude-flow/missions/observation.json` is rewritten atomically after each
+ * committed mission event. It carries the source time (`observedAt`, the time
+ * of the newest committed event); readers stamp their own fetch time and derive
+ * freshness from `observedAt`, never from a redraw. Strings are stripped of
+ * control and bidi characters and truncated here, at write time, so a reader
+ * never sees unbounded or instruction-shaped text from a mission.
+ *
+ * It is observation only. Task status is recorded state; only
+ * `evidence.verified` counts as verified, and an executor marked disconnected
+ * is not a failed mission.
+ */
+export const OBSERVATION_CONTRACT = 'ruflo.mission-observation/1';
+export const OBSERVATION_FILE = 'observation.json';
+export const OBSERVATION_LIMITS = Object.freeze({ missions: 50, tasks: 50, string: 200, objective: 400 });
+/** Strip C0/C1 controls and bidi overrides, then bound the length. */
+export function sanitize(value, max = OBSERVATION_LIMITS.string) {
+    let out = '';
+    for (const ch of value) {
+        const cp = ch.codePointAt(0);
+        if (cp < 0x20 || cp === 0x7f || (cp >= 0x80 && cp <= 0x9f)) {
+            out += ' ';
+            continue;
+        }
+        if ((cp >= 0x202a && cp <= 0x202e) || (cp >= 0x2066 && cp <= 0x2069) || cp === 0x200e || cp === 0x200f)
+            continue;
+        out += ch;
+    }
+    out = out.replace(/\s+/g, ' ').trim();
+    return out.length > max ? `${out.slice(0, max - 1)}…` : out;
+}
+export function observeMission(view) {
+    const plan = view.planBody;
+    return {
+        missionId: view.record.missionId,
+        objective: sanitize(view.record.objective, OBSERVATION_LIMITS.objective),
+        state: view.record.state,
+        revision: view.record.revision,
+        executionMode: view.record.executionMode,
+        plan: {
+            revision: view.record.plan.revision,
+            digest: view.record.plan.digest,
+            taskCount: plan?.tasks.length ?? 0,
+            tasks: (plan?.tasks ?? []).slice(0, OBSERVATION_LIMITS.tasks).map((t) => ({
+                id: sanitize(t.id, 64),
+                title: sanitize(t.title),
+                dependsOn: t.dependsOn.slice(0, 16).map((d) => sanitize(d, 64)),
+                status: view.tasks[t.id]?.status ?? 'pending',
+            })),
+        },
+        budget: view.budget,
+        evidence: { count: view.evidence.length, verified: view.evidence.filter((e) => e.verified).length },
+        executor: view.executor
+            ? { connection: view.executor.connection, observedAt: view.executor.observedAt, lastAckExecutionId: view.executor.lastAckExecutionId }
+            : null,
+        unresolvedOperations: view.unresolvedOperations.length,
+        blockedReason: view.blockedReason ? sanitize(view.blockedReason) : null,
+        lastEventSequence: view.record.lastEventSequence,
+        updatedAt: view.record.updatedAt,
+    };
+}
+/** Newest-updated first, capped; `observedAt` is the newest committed event time. */
+export function buildObservation(workspaceId, views) {
+    const sorted = [...views].sort((a, b) => (a.record.updatedAt < b.record.updatedAt ? 1 : a.record.updatedAt > b.record.updatedAt ? -1 : 0));
+    return {
+        schemaVersion: 1,
+        contract: OBSERVATION_CONTRACT,
+        source: 'ruflo-cli/missions',
+        workspaceId,
+        observedAt: sorted[0]?.record.updatedAt ?? null,
+        truncated: sorted.length > OBSERVATION_LIMITS.missions,
+        missions: sorted.slice(0, OBSERVATION_LIMITS.missions).map(observeMission),
+    };
+}
+//# sourceMappingURL=observation.js.map