crewly 1.6.4 → 1.7.0

package/dist/backend/backend/src/services/v3/request-cascade.subscriber.js

@@ -0,0 +1,152 @@
+/**
+ * RequestCascadeSubscriber — keeps Request.status in sync with the
+ * aggregate state of its child WorkItems by reacting to live task
+ * lifecycle events on the central EventBus.
+ *
+ * **Why this exists.** 2026-05-09 dogfood: `cascadeRequestStatus` lives
+ * inside V3DataService, but the only callers are V3DataService's
+ * onTaskCompleted/onTaskFailed/onTaskBlocked handlers — and those
+ * handlers are wired to the **retired** `v3:task_*` events that nothing
+ * emits anymore (`mission-executor.service.ts:152` v1-cleanup comment).
+ * So the cascade hadn't fired for any task event in months.
+ *
+ * Symptom: a Slack-originated Request whose 4 child WIs all landed in
+ * `cancelled` stayed in `ready` for hours, generating misleading
+ * "0/4, 进行中 0..." heartbeats every sweep.
+ *
+ * **What this subscribes to.** Every live task lifecycle event that the
+ * central EventBus publishes:
+ *   - `task:done_by_worker`   — child finished, awaiting verification
+ *   - `task:verified`         — verifier accepted
+ *   - `task:rejected`         — verifier sent back for retry
+ *   - `task:cancelled`        — child cancelled (added in this PR)
+ *   - `task:failed`           — child failed terminally
+ *   - `task:blocked`          — child wedged
+ *
+ * Each handler resolves `requestId` from the event payload (or by
+ * looking up the WI if the event didn't carry it) and calls
+ * {@link cascadeRequestStatus}, which re-reads pool state and patches
+ * the parent Request to the right status.
+ *
+ * **What this is NOT.** This is not a notification service —
+ * `RequestStatusUpdateSubscriber` handles user-facing Slack updates.
+ * They share the event stream but have separate concerns. (The
+ * heartbeat-driven closer in `RequestStatusUpdateSubscriber` remains
+ * as a 30-min safety net for any cancellation that bypasses the
+ * publish path — e.g. direct storage mutation by an ops script.)
+ *
+ * @module services/v3/request-cascade.subscriber
+ */
+import { LoggerService } from '../core/logger.service.js';
+import { cascadeRequestStatus, } from './cascade-request-status.js';
+/**
+ * Events that may signal a Request needs re-cascading.
+ */
+const SUBSCRIBED_EVENTS = [
+    'task:done_by_worker',
+    'task:verified',
+    'task:rejected',
+    'task:cancelled',
+    'task:failed',
+    'task:blocked',
+];
+export class RequestCascadeSubscriber {
+    eventBus;
+    requestService;
+    taskPool;
+    notifier;
+    logger;
+    unsubscribers = [];
+    started = false;
+    /** In-flight async dispatch promises — exposed via `flushPending` for tests. */
+    pendingDispatches = new Set();
+    constructor(deps) {
+        this.eventBus = deps.eventBus;
+        this.requestService = deps.requestService;
+        this.taskPool = deps.taskPool;
+        this.notifier = deps.notifier;
+        this.logger =
+            deps.logger ?? LoggerService.getInstance().createComponentLogger('RequestCascadeSubscriber');
+    }
+    /**
+     * Subscribe to bus events. Idempotent.
+     */
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        for (const eventType of SUBSCRIBED_EVENTS) {
+            this.unsubscribers.push(this.eventBus.onInProcess(eventType, (e) => this.safeDispatch(eventType, e)));
+        }
+        this.logger.info('RequestCascadeSubscriber subscribed', {
+            eventTypes: SUBSCRIBED_EVENTS,
+        });
+    }
+    /**
+     * Detach subscriptions. Safe to call repeatedly.
+     */
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        for (const unsub of this.unsubscribers) {
+            try {
+                unsub();
+            }
+            catch (err) {
+                this.logger.warn('Unsubscribe failed', {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        this.unsubscribers = [];
+    }
+    /**
+     * Test affordance — wait for any in-flight dispatch promises to settle.
+     */
+    async flushPending() {
+        while (this.pendingDispatches.size > 0) {
+            await Promise.allSettled(Array.from(this.pendingDispatches));
+        }
+    }
+    // -------------------------------------------------------------------------
+    safeDispatch(eventType, event) {
+        const dispatch = (async () => {
+            try {
+                await this.handleTaskEvent(eventType, event);
+            }
+            catch (err) {
+                // Best-effort — never let a cascade failure poison the bus.
+                this.logger.warn('Cascade dispatch failed (non-fatal)', {
+                    eventType,
+                    workItemId: event.workItemId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        })();
+        this.pendingDispatches.add(dispatch);
+        void dispatch.finally(() => this.pendingDispatches.delete(dispatch));
+        return dispatch;
+    }
+    async handleTaskEvent(_eventType, event) {
+        let requestId = event.requestId;
+        // Some emitters don't carry requestId on the event payload (older
+        // call sites, hand-fired test events). Resolve via the WI if we
+        // have a workItemId. If neither is present, there's nothing to
+        // cascade — quietly bail.
+        if (!requestId && event.workItemId) {
+            const wi = await this.taskPool.findWorkItem(event.workItemId);
+            if (wi)
+                requestId = wi.requestId;
+        }
+        if (!requestId)
+            return;
+        await cascadeRequestStatus(requestId, {
+            requestService: this.requestService,
+            taskPool: this.taskPool,
+            logger: this.logger,
+            notifier: this.notifier,
+        });
+    }
+}
+//# sourceMappingURL=request-cascade.subscriber.js.map

package/dist/backend/backend/src/services/v3/request-cascade.subscriber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-cascade.subscriber.js","sourceRoot":"","sources":["../../../../../../backend/src/services/v3/request-cascade.subscriber.ts"],"names":[],"mappings":"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"}

package/dist/backend/backend/src/services/v3/request-decompose.subscriber.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Request Decompose Subscriber — Pipeline-#4 follow-up (Option C).
+ *
+ * **What this fixes**
+ *
+ * `RequestService.plan()` is a PURE FUNCTION that returns a {@link RequestPlan}
+ * but does NOT persist anything or call `taskPool.addToPool` for the planned
+ * tasks. Pipeline-#4 (PR #453) wired the linkage path (workitem:queued →
+ * linkWorkItem → maybeCloseRequest sibling-count gate), but never bridged
+ * `plan() → addToPool`. As a result, any new actionable L2 Request landed
+ * with empty `workItemIds[]` unless the orc manually invoked the
+ * `break-down-request` skill.
+ *
+ * Steve dogfooded the symptom on 2026-05-05: POSTed Requests showed up in
+ * the Requests UI with no children, and the orc had to be prompted to
+ * decompose them. "Rails built but not ridden."
+ *
+ * **What this does**
+ *
+ * Listens on the bus for `request:created`. When the Request is L2 and
+ * carries an actionable `intentCategory`, calls `RequestService.plan()` and
+ * adds each planned task to the pool with `requestId` set on the WorkItem.
+ * The existing PR #453 L4 fix at
+ * `request-sla.subscriber.ts:1153` then auto-links each WorkItem ID into
+ * `Request.workItemIds[]` via the `workitem:queued` → `linkWorkItem`
+ * pipeline — no manual link call needed here.
+ *
+ * **Why a separate subscriber, not a method on RequestSlaSubscriber**
+ *
+ * The SLA subscriber's responsibility is "track the user-reply SLA on
+ * inbound Slack/chat-v2 surfaces". Auto-decomposition is a different
+ * concern (intentLevel filter, plan() invocation, fan-out add-to-pool) and
+ * belongs in its own subscriber so the SLA module's surface stays focused.
+ * Separation also means a future change to the decomposition heuristic
+ * (e.g. richer plan() strategies, intent-aware routing) can land without
+ * disturbing the SLA contract.
+ *
+ * **Co-existence with RequestSlaSubscriber**
+ *
+ * For an L2 inbound-Slack Request, both subscribers fire on the same
+ * `request:created` event. Order is undefined but irrelevant:
+ *   - SLA seeds the `respond_to_user` WI immediately, syncing the threadTs
+ *     index for the bridge's `markResolvedByThread` lookup.
+ *   - This subscriber plans + queues the actual decomposition WIs.
+ *   - The first non-respond_to_user `workitem:queued` triggers the SLA
+ *     subscriber's `handleWorkItemQueued`, which (a) calls `linkWorkItem`
+ *     (PR #453 L4) and (b) calls `markResolved(requestId,
+ *     'workitem_decompose')` to retire the SLA tracker.
+ *   - The Pipeline-#4 L5 grace window inside `maybeCloseRequest` keeps the
+ *     parent Request open until siblings are linked, suppressing the
+ *     premature `orc_reply` cascade close that the original bug would have
+ *     triggered.
+ *
+ * Net effect: a POSTed L2 Request now lands with WorkItems within ~ms of
+ * `request:created` publish, and the close-cascade behaves as designed.
+ *
+ * **Idempotence on redelivery**
+ *
+ * Two safeguards:
+ *   1. In-memory `decomposedRequestIds` Set guards against the same event
+ *      being delivered twice within process lifetime. O(1) check, no
+ *      cross-process synchronisation needed.
+ *   2. Belt-and-suspenders: even if the in-memory guard misses (e.g.
+ *      restart between deliveries), `taskPool.addToPool` already
+ *      short-circuits on duplicate id. We use deterministic ids — the
+ *      uuidv4 from `createWorkItem` is non-deterministic, so the dup-check
+ *      protects us only against the in-memory replay; cross-process replay
+ *      protection is the `request.workItemIds.length > 0` skip below.
+ *
+ * **Skip rules** (in order; first match wins):
+ *   - `intentLevel !== 'L2'` (L0/L1 are non-decomposing surfaces)
+ *   - `intentCategory ∉ ACTIONABLE_CATEGORIES`
+ *   - `request.workItemIds.length > 0` (caller already manually decomposed)
+ *   - `decomposedRequestIds.has(request.id)` (already processed in this
+ *     process lifetime)
+ *   - `plan.tasks.length === 0` or `plan.strategy === 'none'`
+ *
+ * @module services/v3/request-decompose.subscriber
+ */
+import { type ComponentLogger } from '../core/logger.service.js';
+import type { EventBusService } from '../event-bus/event-bus.service.js';
+import { RequestService } from './request.service.js';
+import { TaskPoolService } from '../task-pool/task-pool.service.js';
+import type { EventType } from '../../types/event-bus.types.js';
+import type { IntentCategory } from '../../types/v2/request.types.js';
+/**
+ * Intent categories the auto-decompose subscriber will plan + fan-out for.
+ *
+ * Choice rationale:
+ *   - `planning`     — explicit decomposition request; canonical use case.
+ *   - `code_change`  — feature/refactor work; multi-step plan pays off.
+ *   - `debugging`    — investigation + fix + verify benefits from split.
+ *   - `deployment`   — multi-step coordination (build/ship/verify).
+ *   - `research`     — survey + synthesise + report fans out cleanly.
+ *
+ * Excluded:
+ *   - `query`        — single-shot lookup; decomposition adds noise.
+ *   - `review`       — single artefact-bound; the orc handles inline.
+ *   - `communication`— L1 surface; usually handled by SLA respond_to_user.
+ *   - `other`        — explicitly opt-out for ambiguous shapes.
+ *
+ * The original brief listed `team_management` here — that is not a valid
+ * IntentCategory in the type system (verified against
+ * `backend/src/types/v2/request.types.ts:61-70`). Substituted `research`
+ * which is genuinely actionable and decomposes well.
+ */
+export declare const ACTIONABLE_INTENT_CATEGORIES: ReadonlySet<IntentCategory>;
+/**
+ * Event types this subscriber listens to. Exported so wiring code can
+ * cross-reference what's subscribed without re-parsing the class.
+ */
+export declare const REQUEST_DECOMPOSE_SUBSCRIBED_EVENTS: readonly EventType[];
+/**
+ * Constructor dependencies. Production wiring uses {@link RequestDecomposeSubscriber.boot};
+ * tests construct directly with fakes.
+ */
+export interface RequestDecomposeSubscriberDependencies {
+    /** Live event bus. */
+    eventBus: EventBusService;
+    /** Live RequestService for plan() + getById. */
+    requestService: RequestService;
+    /** Live TaskPoolService for addToPool. */
+    taskPool: TaskPoolService;
+    /** Override actionable categories (testing). */
+    actionableCategories?: ReadonlySet<IntentCategory>;
+    /** Optional logger override. */
+    logger?: ComponentLogger;
+}
+/**
+ * Production hook — set the active subscriber instance during boot so
+ * shutdown code can find it. Tests bypass this by constructing directly.
+ *
+ * @param subscriber - The active subscriber, or `null` to clear.
+ */
+export declare function setRequestDecomposeSubscriber(subscriber: RequestDecomposeSubscriber | null): void;
+/**
+ * Read-only access to the active subscriber. Used by shutdown code in
+ * `index.ts` and by debugging tooling.
+ *
+ * @returns The active subscriber, or `null` if not booted.
+ */
+export declare function getRequestDecomposeSubscriber(): RequestDecomposeSubscriber | null;
+/**
+ * Auto-decomposes new actionable L2 Requests into pool WorkItems.
+ *
+ * @example
+ * ```typescript
+ * const sub = RequestDecomposeSubscriber.boot(eventBus, requestService, taskPool);
+ * sub.start();
+ * // … on shutdown:
+ * sub.stop();
+ * ```
+ */
+export declare class RequestDecomposeSubscriber {
+    private readonly eventBus;
+    private readonly requestService;
+    private readonly taskPool;
+    private readonly actionableCategories;
+    private readonly logger;
+    private unsubscribers;
+    private started;
+    /**
+     * In-memory dedupe of Request IDs that have already been auto-decomposed
+     * by this process. Protects against bus redelivery within process
+     * lifetime. Cross-process replay (restart) is handled by the
+     * `request.workItemIds.length > 0` skip rule in {@link handleRequestCreated}.
+     */
+    private readonly decomposedRequestIds;
+    /** In-flight async dispatch promises (test affordance). */
+    private readonly pendingDispatches;
+    constructor(deps: RequestDecomposeSubscriberDependencies);
+    /**
+     * Production wiring helper. Tests should use the constructor directly.
+     *
+     * @param eventBus - Live event bus
+     * @param requestService - Live RequestService
+     * @param taskPool - Live TaskPoolService
+     * @returns A subscriber ready to `start()`
+     */
+    static boot(eventBus: EventBusService, requestService: RequestService, taskPool: TaskPoolService): RequestDecomposeSubscriber;
+    /**
+     * Subscribe + register the in-process handlers. Idempotent.
+     */
+    start(): void;
+    /**
+     * Wait for in-flight async dispatches to settle. Test affordance.
+     *
+     * @returns Promise that resolves when all pending dispatches finish.
+     */
+    flushPending(): Promise<void>;
+    /**
+     * Detach subscriptions. Safe to call repeatedly.
+     */
+    stop(): void;
+    /**
+     * Test-only accessor for the dedupe set. Useful for verifying the
+     * in-memory guard from integration tests.
+     *
+     * @returns The set of Request IDs already processed by this instance.
+     */
+    getDecomposedRequestIdsSnapshot(): ReadonlySet<string>;
+    /**
+     * `request:created` handler. Filters by intentLevel + actionable
+     * intentCategory, calls plan(), and adds each planned task to the pool
+     * as a WorkItem with `requestId` set. The existing PR #453 L4 fix
+     * (`request-sla.subscriber.ts:handleWorkItemQueued`) auto-links each WI
+     * into `Request.workItemIds[]`, so no manual `linkWorkItem` call is
+     * needed here.
+     *
+     * @param event - The `request:created` event from the bus.
+     */
+    private handleRequestCreated;
+    /**
+     * Filter predicate. Returns true iff the Request should be auto-decomposed.
+     * Logs the specific skip reason at debug level so ops can correlate
+     * "I POSTed a Request but no WIs appeared" with the rule that excluded it.
+     *
+     * @param request - The Request to evaluate.
+     * @returns True if this subscriber should plan + addToPool for this Request.
+     */
+    private shouldDecompose;
+    /**
+     * Builds a pool-ready WorkItem from a planned task. Mirrors the
+     * `break-down-request` skill's WI shape (owner=orchestrator, no preset
+     * target → orc routes during fan-out) so consumers downstream can't
+     * tell whether the decomposition came from the skill or this subscriber.
+     *
+     * @param task - The planned task from RequestService.plan()
+     * @param request - The parent Request (provides id + missionId for back-refs)
+     * @returns A queued WorkItem ready for `taskPool.addToPool`.
+     */
+    private buildWorkItemFromTask;
+    /**
+     * Combine PlannedTask description + acceptance criteria into a single
+     * description block visible to the agent picking up the WorkItem.
+     * Acceptance criteria render as a bullet list under a header so the
+     * agent's prompt-builder can surface them inline.
+     *
+     * @param task - The planned task.
+     * @returns Combined description + criteria block.
+     */
+    private formatDescription;
+    /**
+     * Wrap a dispatch so a thrown handler is logged and isolated. Mirrors
+     * `RequestSlaSubscriber.safeDispatch`.
+     *
+     * @param eventType - The event type that triggered this dispatch
+     * @param event - The event payload
+     * @returns Promise that resolves when the handler finishes (or throws).
+     */
+    private safeDispatch;
+}
+//# sourceMappingURL=request-decompose.subscriber.d.ts.map

package/dist/backend/backend/src/services/v3/request-decompose.subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-decompose.subscriber.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/v3/request-decompose.subscriber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAEH,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,mCAAmC,CAAC;AAC/F,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,KAAK,EAAc,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,KAAK,EAAW,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAU/E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,4BAA4B,EAAE,WAAW,CAAC,cAAc,CAMnE,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,mCAAmC,EAAE,SAAS,SAAS,EAE1D,CAAC;AAMX;;;GAGG;AACH,MAAM,WAAW,sCAAsC;IACrD,sBAAsB;IACtB,QAAQ,EAAE,eAAe,CAAC;IAC1B,gDAAgD;IAChD,cAAc,EAAE,cAAc,CAAC;IAC/B,0CAA0C;IAC1C,QAAQ,EAAE,eAAe,CAAC;IAC1B,gDAAgD;IAChD,oBAAoB,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IACnD,gCAAgC;IAChC,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;AAQD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,0BAA0B,GAAG,IAAI,GAC5C,IAAI,CAEN;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,IAAI,0BAA0B,GAAG,IAAI,CAEjF;AAMD;;;;;;;;;;GAUG;AACH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;IACnE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,OAAO,CAAS;IACxB;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA0B;IAC/D,2DAA2D;IAC3D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAiC;gBAEvD,IAAI,EAAE,sCAAsC;IASxD;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CACT,QAAQ,EAAE,eAAe,EACzB,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,eAAe,GACxB,0BAA0B;IAQ7B;;OAEG;IACH,KAAK,IAAI,IAAI;IAgBb;;;;OAIG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAOnC;;OAEG;IACH,IAAI,IAAI,IAAI;IAeZ;;;;;OAKG;IACI,+BAA+B,IAAI,WAAW,CAAC,MAAM,CAAC;IAQ7D;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB,CAmH1B;IAEF;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe;IAiDvB;;;;;;;;;OASG;IACH,OAAO,CAAC,qBAAqB;IAmB7B;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;CAwBrB"}