@telora/daemon 0.17.36 → 0.17.42

package/dist/directive/phase-sync.js

@@ -0,0 +1,173 @@
+/**
+ * Phase sync: stage detection for the directive edge-trigger.
+ *
+ * Decides which workflow stage a focus should be in (new lifecycle stage
+ * names take priority over the legacy delivery-aggregate phase derivation),
+ * synchronizes `product_focuses.current_workflow_stage_id` with that decision,
+ * detects stranded reviews that need a directive re-fire, and fires on_enter
+ * transition triggers. Extracted from directive-executor.ts; the executor
+ * re-exports the public surface so existing importers are unaffected.
+ */
+import { fetchFocusWorkflow, fetchFocusWorkflowWithTransitions, getFocusDeliveries, updateFocusWorkflowStage, } from '../queries/focuses.js';
+import { fetchTransitionGuards } from '../queries/guards.js';
+import { executeAdvanceLinkedInjections } from '../trigger-executor.js';
+import { deriveFocusPhase } from '../focus-phase.js';
+// ── Focus transition trigger execution ────────────────────────
+/**
+ * Fire on_enter triggers for a focus stage transition.
+ *
+ * Looks up the workflow transition from lastStageId to currentStageId,
+ * fetches triggers on that transition, and executes on_enter triggers.
+ * Currently supports advance_linked_injections; other action types
+ * are logged and skipped.
+ */
+export async function fireFocusTransitionTriggers(focusId, lastStageId, currentStageId) {
+    if (!lastStageId)
+        return; // First time seeing this focus, no transition to fire
+    try {
+        // Find the transition between the two stages
+        const workflow = await fetchFocusWorkflowWithTransitions(focusId);
+        const transition = workflow.transitions?.find(t => t.from_stage_id === lastStageId && t.to_stage_id === currentStageId);
+        if (!transition)
+            return; // No transition found (possible for non-standard stage jumps)
+        // Fetch triggers on this transition
+        const resolved = await fetchTransitionGuards(transition.id);
+        const onEnterTriggers = resolved.triggers.filter(t => t.trigger_event === 'on_enter');
+        if (onEnterTriggers.length === 0)
+            return;
+        for (const trigger of onEnterTriggers) {
+            try {
+                if (trigger.action_type === 'advance_linked_injections') {
+                    await executeAdvanceLinkedInjections(focusId, trigger.action_config);
+                }
+                else {
+                    console.log(`[directive-executor] Focus trigger "${trigger.name}" (${trigger.action_type}) ` +
+                        `skipped -- not supported in focus context`);
+                }
+            }
+            catch (err) {
+                console.warn(`[directive-executor] Failed to execute focus trigger "${trigger.name}":`, err.message);
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`[directive-executor] Failed to fire focus transition triggers for ${focusId.slice(0, 8)}:`, err.message);
+    }
+}
+// ── Phase sync ───────────────────────────────────────────────────
+/**
+ * New focus workflow lifecycle stage names introduced by D1
+ * (20260513152817_focus_workflow_lifecycle_and_tree_closure.sql).
+ *
+ * When `product_focuses.stage` is one of these, the daemon takes the
+ * denormalized `focus.stage` as authoritative and maps it directly to the
+ * matching workflow_stages row — this is how the new lifecycle (verify ->
+ * review -> close_loop -> done) drives the daemon, rather than the legacy
+ * delivery-aggregate phase derivation. The legacy derivation is kept as a
+ * fallback for focuses still on the older
+ * kickoff/coding/verifying/reviewing/winding_down flow.
+ */
+const LIFECYCLE_STAGE_NAMES = new Set([
+    'queued',
+    'verify',
+    'review',
+    'close_loop',
+    'done',
+]);
+/**
+ * Decide which workflow stage name a focus should be in.
+ *
+ * Pure helper, exported for testing. The selection rule is:
+ *   1. If `focus.stage` is one of the new lifecycle stage names
+ *      (`queued`/`verify`/`review`/`close_loop`/`done`), use it directly.
+ *      The denormalized stage is the authoritative signal under the new
+ *      workflow.
+ *   2. Otherwise, fall back to the legacy phase derived from the delivery
+ *      aggregate (kickoff/coding/verifying/reviewing/winding_down/blocked).
+ *
+ * Note: `review_requested_at` is still read by the legacy derivation for
+ * back-compat -- but on the new lifecycle path the `review` stage transition
+ * is driven by writes to `product_focuses.stage`, not by writes to
+ * `review_requested_at`. This is the Issue 1 contract.
+ */
+export function resolveFocusStageName(input) {
+    if (input.focusStage && LIFECYCLE_STAGE_NAMES.has(input.focusStage)) {
+        return input.focusStage;
+    }
+    return deriveFocusPhase({
+        deliveries: input.deliveries,
+        reviewRequestedAt: input.reviewRequestedAt,
+    });
+}
+/**
+ * Stage names that represent the focus review window: 'reviewing' on the
+ * legacy delivery-aggregate phase derivation, 'review' on the new focus
+ * workflow lifecycle. Either means "a review is the gate to done".
+ */
+const REVIEW_STAGE_NAMES = new Set(['reviewing', 'review']);
+/**
+ * Decide whether to re-fire a focus's review-stage directive even though the
+ * edge-trigger (lastProcessedStages) already marked the stage processed.
+ *
+ * The edge-trigger fires a stage directive exactly once per stage entry. For
+ * the review stage that is normally correct -- a clean review completes, clears
+ * review_requested_at, and the focus leaves the review phase. But if the review
+ * team never spawned or was killed (e.g. a lifecycle SIGTERM) before routing,
+ * the focus stays in the review stage with review_requested_at still set and the
+ * directive never re-fires: a silent stuck focus (the founding bug of this focus).
+ *
+ * A focus STILL in the review stage with review_requested_at set is provably
+ * stranded -- any completed review clears review_requested_at and moves the
+ * phase. So when no review team is running, re-firing the directive is the
+ * self-healing recovery: it respawns the review team. Once a team is running the
+ * active-team guard suppresses the re-fire, and a successful review auto-approves
+ * and leaves the stage -- so the re-fire is bounded, not a per-poll spin.
+ *
+ * Pure and exported for unit testing.
+ */
+export function shouldRefireStrandedReview(input) {
+    if (!input.stageName || !REVIEW_STAGE_NAMES.has(input.stageName))
+        return false;
+    if (!input.reviewRequestedAt)
+        return false;
+    if (input.hasActiveTeam)
+        return false;
+    return true;
+}
+/**
+ * Synchronize `product_focuses.current_workflow_stage_id` with the focus's
+ * authoritative stage. The authoritative stage is taken from `focus.stage`
+ * when it names one of the new lifecycle stages (Issue 1); otherwise the
+ * legacy delivery-aggregate phase derivation applies.
+ *
+ * Returns the stage ID the focus should be in (post-sync). Falls back to
+ * the recorded stage id on error so callers don't have to handle a third
+ * "unknown" state.
+ */
+export async function syncFocusPhase(focus) {
+    try {
+        const deliveries = await getFocusDeliveries(focus.focus_id);
+        const stageName = resolveFocusStageName({
+            focusStage: focus.stage ?? null,
+            deliveries: deliveries.map((d) => ({ executionStatus: d.executionStatus })),
+            reviewRequestedAt: focus.review_requested_at,
+        });
+        const workflow = await fetchFocusWorkflow(focus.focus_id);
+        const stage = workflow.stages.find((s) => s.name === stageName);
+        if (!stage) {
+            console.warn(`[directive-executor] No "${stageName}" stage in workflow for focus ` +
+                `${focus.focus_id.slice(0, 8)}; phase sync skipped.`);
+            return focus.current_workflow_stage_id;
+        }
+        if (stage.id !== focus.current_workflow_stage_id) {
+            await updateFocusWorkflowStage(focus.focus_id, stage.id);
+            console.log(`[directive-executor] Focus ${focus.focus_id.slice(0, 8)} stage -> ${stageName}`);
+        }
+        return stage.id;
+    }
+    catch (err) {
+        console.warn(`[directive-executor] Phase sync failed for focus ${focus.focus_id.slice(0, 8)}:`, err.message);
+        return focus.current_workflow_stage_id;
+    }
+}
+//# sourceMappingURL=phase-sync.js.map

package/dist/directive/phase-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-sync.js","sourceRoot":"","sources":["../../src/directive/phase-sync.ts"],"names":[],"mappings":"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"}

package/dist/directive-executor.d.ts

@@ -1,231 +1,29 @@
 /**
- * Directive Executor.
+ * Directive Executor -- thin orchestrating entry point.
  *
- * Detects focus workflow stage changes and executes the stage's
- * agent_directive. For inject mode: writes /compact + prompt via stdin.
- * For spawn mode: terminates current session, assembles directive content,
- * and stores it for the next spawn cycle to deliver.
- */
-import type { DaemonConfig, StageDirective, DirectiveExecutionMode } from './types.js';
-import { type AssemblyManifestEntry } from './assembly-engine.js';
-import './assembly-resolvers.js';
-import { type LineageSpec } from './session-lineage.js';
-import { type CloseLoopDecision } from './close-loop-dispatcher.js';
-import { createEscalation } from './queries/issues.js';
-export { seedLastProcessedStage, getLastProcessedStages } from './directive/stage-tracker.js';
-export { computeDirectiveHash, SPAWN_GUARD_WINDOW_MS, shouldSkipSpawnDirective, consumePendingSpawnDirective, __setPendingSpawnDirectiveForTesting, hasPendingSpawnDirective, getPendingSpawnDirective, getPendingSpawnFocusIds, shouldSuppressRefireForPendingSpawn, type PendingSpawnDirective, } from './directive/directive-queue.js';
-/** Assembled directive content paired with its per-source attribution manifest. */
-export interface AssembledDirective {
-    content: string;
-    manifest: AssemblyManifestEntry[];
-}
-/**
- * Assemble directive content from a StageDirective's recipe and prompt.
- * Shared by both inject and spawn modes, and by focus-executor for
- * initial spawn with a stage directive.
- */
-export declare function assembleDirectiveContent(config: DaemonConfig, focusId: string, directive: StageDirective, worktreePath: string | null): Promise<string>;
-/**
- * Assemble directive content AND return the assembly manifest (one entry per
- * recipe source). The composed `content` is identical to
- * assembleDirectiveContent; the manifest lets the spawn path persist what
- * context was injected. The manifest covers ONLY the assembly recipe -- the
- * static directive.prompt / tool guidance are not assembly sources.
- */
-export declare function assembleDirectiveContentWithManifest(config: DaemonConfig, focusId: string, directive: StageDirective, worktreePath: string | null): Promise<AssembledDirective>;
-/**
- * Resolve the execution mode a directive should dispatch under.
- *
- * Pure + exported for testing. The rule:
- *   - A valid mode ('inject' | 'spawn') passes through unchanged.
- *   - A review-lineage directive whose execution is missing/invalid defaults
- *     to 'spawn'. Review always spawns a fresh team, so 'spawn' is the only
- *     sensible mode for that lineage; defaulting here self-heals malformed or
- *     seed-drifted review directives (e.g. the focus 'review' stage whose
- *     agent_directive lost its execution field -- see the backfill migration)
- *     so the review-spawn path can no longer be silently stranded.
- *   - Anything else is UNRESOLVABLE (returns null). The caller treats null as
- *     a fail-loud condition (throw -> escalate + loop trigger) rather than a
- *     silent no-op.
- *
- * Note: a review-lineage directive defaults to spawn even for a non-empty but
- * unrecognized execution value -- review is always spawnable, so we self-heal
- * rather than fail. Non-review lineages have no safe default and fail loud.
- */
-export declare function resolveDirectiveExecutionMode(execution: string | null | undefined, lineage: string): DirectiveExecutionMode | null;
-/**
- * Execute a stage directive for a focus.
- *
- * inject mode: sends /compact + assembled context + prompt to the active team's stdin.
- * spawn mode: terminates the current team, assembles directive content, stores for respawn.
- *
- * When the directive's execution mode cannot be resolved to a valid mode
- * (see resolveDirectiveExecutionMode), this THROWS instead of silently
- * no-oping. The throw propagates through runDirectiveWithRetry in
- * checkDirectives, which escalates and emits a loop trigger -- so a malformed
- * directive surfaces a signal instead of stranding the focus.
- *
- * Exported for testing.
- */
-export declare function executeDirective(config: DaemonConfig, focusId: string, directive: StageDirective, focusWorkflowStageId: string, stageName?: string): Promise<void>;
-/**
- * Inject mode: send /compact + assembled context + prompt to the active team's stdin.
- */
-export declare function executeInjectDirective(config: DaemonConfig, focusId: string, directive: StageDirective, sessionType?: 'coding' | 'review', spec?: LineageSpec): Promise<void>;
-/**
- * Decide which workflow stage name a focus should be in.
- *
- * Pure helper, exported for testing. The selection rule is:
- *   1. If `focus.stage` is one of the new lifecycle stage names
- *      (`queued`/`verify`/`review`/`close_loop`/`done`), use it directly.
- *      The denormalized stage is the authoritative signal under the new
- *      workflow.
- *   2. Otherwise, fall back to the legacy phase derived from the delivery
- *      aggregate (kickoff/coding/verifying/reviewing/winding_down/blocked).
- *
- * Note: `review_requested_at` is still read by the legacy derivation for
- * back-compat -- but on the new lifecycle path the `review` stage transition
- * is driven by writes to `product_focuses.stage`, not by writes to
- * `review_requested_at`. This is the Issue 1 contract.
- */
-export declare function resolveFocusStageName(input: {
-    focusStage: string | null | undefined;
-    deliveries: Array<{
-        executionStatus: string | null;
-    }>;
-    reviewRequestedAt: string | null;
-}): string;
-/**
- * Decide whether to re-fire a focus's review-stage directive even though the
- * edge-trigger (lastProcessedStages) already marked the stage processed.
+ * "What happens when a stage changes" reads from here: checkDirectives
+ * (called from the daemon poll loop) walks active focuses, syncs each
+ * focus's workflow stage, and edge-triggers the stage's agent_directive.
+ * The real logic lives in focused modules under directive/:
  *
- * The edge-trigger fires a stage directive exactly once per stage entry. For
- * the review stage that is normally correct -- a clean review completes, clears
- * review_requested_at, and the focus leaves the review phase. But if the review
- * team never spawned or was killed (e.g. a lifecycle SIGTERM) before routing,
- * the focus stays in the review stage with review_requested_at still set and the
- * directive never re-fires: a silent stuck focus (the founding bug of this focus).
+ *   - directive/phase-sync.ts        stage detection + phase sync + transition triggers
+ *   - directive/directive-assembly.ts assembly of directive content (recipe + prompt + tools)
+ *   - directive/directive-dispatch.ts inject-to-stdin / spawn-queue execution + bounded retry
+ *   - directive/close-loop-stage.ts  close_loop stage dispatcher (bookkeeper + sweep)
+ *   - directive/stage-tracker.ts     lastProcessedStages map + accessors
+ *   - directive/directive-queue.ts   pendingSpawnDirectives map + identity/guard helpers
  *
- * A focus STILL in the review stage with review_requested_at set is provably
- * stranded -- any completed review clears review_requested_at and moves the
- * phase. So when no review team is running, re-firing the directive is the
- * self-healing recovery: it respawns the review team. Once a team is running the
- * active-team guard suppresses the re-fire, and a successful review auto-approves
- * and leaves the stage -- so the re-fire is bounded, not a per-poll spin.
- *
- * Pure and exported for unit testing.
- */
-export declare function shouldRefireStrandedReview(input: {
-    stageName: string | undefined;
-    reviewRequestedAt: string | null;
-    hasActiveTeam: boolean;
-}): boolean;
-/**
- * Synchronize `product_focuses.current_workflow_stage_id` with the focus's
- * authoritative stage. The authoritative stage is taken from `focus.stage`
- * when it names one of the new lifecycle stages (Issue 1); otherwise the
- * legacy delivery-aggregate phase derivation applies.
- *
- * Returns the stage ID the focus should be in (post-sync). Falls back to
- * the recorded stage id on error so callers don't have to handle a third
- * "unknown" state.
- */
-export declare function syncFocusPhase(focus: {
-    focus_id: string;
-    current_workflow_stage_id: string | null;
-    review_requested_at: string | null;
-    /**
-     * Denormalized lifecycle stage from product_focuses.stage. Optional for
-     * back-compat with old API responses; absence is treated as "fall back to
-     * the legacy phase derivation".
-     */
-    stage?: string | null;
-}): Promise<string | null>;
-/**
- * Result of a bounded-retry attempt to run a directive. The retry is on
- * ANY thrown error (assembly resolver throws, fetch failures, Supabase
- * timeouts) -- broader than `withRetry` from daemon-core, which classifies
- * by error type. Transient failures during directive execution are not
- * always classified as network errors, but they're still worth retrying
- * before treating as permanent.
+ * This module RE-EXPORTS the full prior public surface so existing importers
+ * (listener, focus-executor, spawner/spawn-team, completion/team-completion,
+ * tests) are unaffected.
  */
-export interface DirectiveRunResult {
-    /** Whether the directive ran to completion within the retry bound. */
-    ok: boolean;
-    /** Number of attempts made (1 = first attempt succeeded). */
-    attempts: number;
-    /** Last error if the retry bound was exhausted, null on success. */
-    error: Error | null;
-}
-export interface RunDirectiveOptions {
-    maxAttempts?: number;
-    baseDelayMs?: number;
-    label: string;
-    /** Sleep implementation -- override in tests to avoid real delays. */
-    sleep?: (ms: number) => Promise<void>;
-    /** Called once per failed attempt before the backoff sleep. */
-    onAttemptFailed?: (attempt: number, error: Error) => void;
-}
-/**
- * Run a directive function with bounded retry and exponential backoff.
- * Returns a result tuple instead of throwing so the caller can decide
- * whether to escalate or continue.
- */
-export declare function runDirectiveWithRetry(fn: () => Promise<void>, options: RunDirectiveOptions): Promise<DirectiveRunResult>;
-/**
- * Escalate when bounded retry of a stage directive is exhausted.
- *
- * Visible signal so operators can find which focus + stage failed and
- * why, instead of a buried console.warn. Mirrors escalatePlanningFailure
- * from focus-completion-event.ts.
- */
-export declare function escalateDirectiveFailure(params: {
-    organizationId: string;
-    sessionId: string;
-    focusId: string;
-    focusName: string;
-    stageName: string | undefined;
-    error: Error;
-    attempts: number;
-}, deps?: {
-    createEscalation: typeof createEscalation;
-}): Promise<void>;
-/** Test helper: clear the bookkeeper-spawned set. */
-export declare function __resetCloseLoopStateForTesting(): void;
-/**
- * Inspect open escalations and return the set of injection ids that have
- * an active `injection_unverified` escalation (status pending or
- * in_review). Used by the close_loop dispatcher to classify "escalated"
- * injections as terminal.
- *
- * The `metadata.injection_id` field is set by the bookkeeper persona when
- * filing the escalation -- see the close_loop directive prompt.
- */
-export declare function getOpenInjectionUnverifiedEscalationIds(): Promise<Set<string>>;
-/**
- * Dispatch the close_loop stage for one focus.
- *
- * Reads the focus's anchored deliveries + injection statuses + open
- * escalations, then runs the pure `decideCloseLoop` to determine whether
- * to short-circuit, spawn a bookkeeper, advance to done, or hold.
- *
- * Returns the decision so the caller (or a test) can log/assert.
- *
- * Idempotent across poll cycles -- the `closeLoopBookkeeperSpawned` set
- * ensures the bookkeeper is spawned at most once per focus visit to
- * close_loop. Tests reset this via `__resetCloseLoopStateForTesting`.
- */
-export declare function dispatchCloseLoopStage(config: DaemonConfig, focus: {
-    focus_id: string;
-    focus_name: string;
-}): Promise<CloseLoopDecision>;
-/**
- * Pure helper exported for tests: build the close_loop directive and verify
- * it carries the expected assembly + model. The buildCloseLoopDirective
- * function in close-loop-dispatcher.ts already does this; this is a
- * dispatcher-side smoke export so the tests can grep through it.
- */
-export declare function getCloseLoopDirectiveForTesting(): StageDirective;
+import type { DaemonConfig } from './types.js';
+export { seedLastProcessedStage, getLastProcessedStages } from './directive/stage-tracker.js';
+export { computeDirectiveHash, SPAWN_GUARD_WINDOW_MS, shouldSkipSpawnDirective, consumePendingSpawnDirective, __setPendingSpawnDirectiveForTesting, hasPendingSpawnDirective, getPendingSpawnDirective, getPendingSpawnFocusIds, shouldSuppressRefireForPendingSpawn, type PendingSpawnDirective, } from './directive/directive-queue.js';
+export { type AssembledDirective, assembleDirectiveContent, assembleDirectiveContentWithManifest, } from './directive/directive-assembly.js';
+export { fireFocusTransitionTriggers, resolveFocusStageName, shouldRefireStrandedReview, syncFocusPhase, } from './directive/phase-sync.js';
+export { resolveDirectiveExecutionMode, executeDirective, executeInjectDirective, type DirectiveRunResult, type RunDirectiveOptions, runDirectiveWithRetry, escalateDirectiveFailure, } from './directive/directive-dispatch.js';
+export { __resetCloseLoopStateForTesting, getOpenInjectionUnverifiedEscalationIds, dispatchCloseLoopStage, getCloseLoopDirectiveForTesting, } from './directive/close-loop-stage.js';
 /**
  * Check all active focuses for stage changes with directives.
  *

package/dist/directive-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directive-executor.d.ts","sourceRoot":"","sources":["../src/directive-executor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"directive-executor.d.ts","sourceRoot":"","sources":["../src/directive-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA+B/C,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC9F,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,4BAA4B,EAC5B,oCAAoC,EACpC,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,mCAAmC,EACnC,KAAK,qBAAqB,GAC3B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,KAAK,kBAAkB,EACvB,wBAAwB,EACxB,oCAAoC,GACrC,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,EACrB,0BAA0B,EAC1B,cAAc,GACf,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,6BAA6B,EAC7B,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,+BAA+B,EAC/B,uCAAuC,EACvC,sBAAsB,EACtB,+BAA+B,GAChC,MAAM,iCAAiC,CAAC;AAIzC;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA0LzE"}