agentix-cli 0.18.0 → 0.19.0

package/dist/chunk-QW2OYR3N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/crons/scheduler.ts","../src/intent/mode.ts","../src/intent/governance.ts","../src/intent/decide.ts","../src/intent/divergence.ts","../src/intent/sources/cron.ts"],"sourcesContent":["import type { DaemonConfig, CronJobDef } from \"@/daemon/config\"\nimport type { AgentRegistry } from \"@/agents/registry\"\nimport type { HookRegistry } from \"@/hooks\"\nimport type { CronJobState, CronRunResult } from \"./types\"\nimport { writeFileSync, mkdirSync, existsSync, readFileSync } from \"fs\"\nimport { resolve } from \"path\"\nimport { applyConfigMutation, setAtPath } from \"@/daemon/config-mutator\"\nimport { getLedgerMode } from \"@/intent/mode\"\nimport { getDefaultLedger } from \"@/intent/instance\"\nimport { recordCronDispatch } from \"@/intent/sources/cron\"\n\n// --- Cron Scheduler: lightweight cron engine with timezone support ---\n// No external dependencies — uses setTimeout-based scheduling.\n\n/**\n * Append a soft output-length cap to a cron prompt when the job configured\n * `maxOutputTokens`. Claude Code CLI has no hard flag for output length,\n * but a clear instruction at the end of the prompt is reliably honored by\n * the model. Keeps a cheap knob available for operators without us needing\n * to invent our own token counter or hack a post-response truncate.\n */\nfunction withOutputCap(prompt: string, maxOutputTokens?: number): string {\n  if (!maxOutputTokens) return prompt\n  const approxChars = maxOutputTokens * 4\n  return `${prompt}\\n\\n[Response budget]\\nKeep your response under ~${maxOutputTokens} tokens (~${approxChars} chars). Be concise — this is automated batch work, not a conversation.`\n}\n\n/**\n * Parse a cron expression into next-fire timestamp.\n * Supports standard 5-field format: minute hour day-of-month month day-of-week\n */\nfunction parseCronField(field: string, min: number, max: number): number[] {\n  const values: number[] = []\n\n  for (const part of field.split(\",\")) {\n    if (part === \"*\") {\n      for (let i = min; i <= max; i++) values.push(i)\n    } else if (part.includes(\"/\")) {\n      const [range, stepStr] = part.split(\"/\")\n      const step = parseInt(stepStr, 10)\n      const start = range === \"*\" ? min : parseInt(range, 10)\n      for (let i = start; i <= max; i += step) values.push(i)\n    } else if (part.includes(\"-\")) {\n      const [a, b] = part.split(\"-\").map(Number)\n      for (let i = a; i <= b; i++) values.push(i)\n    } else {\n      values.push(parseInt(part, 10))\n    }\n  }\n\n  return [...new Set(values)].sort((a, b) => a - b)\n}\n\nexport function getNextCronDate(expression: string, after: Date, timezone: string): Date {\n  const fields = expression.trim().split(/\\s+/)\n  if (fields.length !== 5) throw new Error(`Invalid cron: ${expression}`)\n\n  const minutes = parseCronField(fields[0], 0, 59)\n  const hours = parseCronField(fields[1], 0, 23)\n  const daysOfMonth = parseCronField(fields[2], 1, 31)\n  const months = parseCronField(fields[3], 1, 12)\n  const daysOfWeek = parseCronField(fields[4], 0, 6)\n\n  // Convert to timezone-aware date\n  const fmt = new Intl.DateTimeFormat(\"en-US\", {\n    timeZone: timezone,\n    year: \"numeric\",\n    month: \"2-digit\",\n    day: \"2-digit\",\n    hour: \"2-digit\",\n    minute: \"2-digit\",\n    hour12: false,\n  })\n\n  // Start searching from next minute\n  const candidate = new Date(after.getTime() + 60_000)\n  candidate.setSeconds(0, 0)\n\n  // Search up to 1 year ahead\n  const limit = new Date(candidate.getTime() + 366 * 24 * 60 * 60 * 1000)\n\n  while (candidate < limit) {\n    const parts = fmt.formatToParts(candidate)\n    const get = (type: string) => parseInt(parts.find((p) => p.type === type)?.value || \"0\", 10)\n\n    const m = get(\"minute\")\n    const h = get(\"hour\")\n    const dom = get(\"day\")\n    const mon = get(\"month\")\n    const dow = candidate.getDay()\n\n    if (\n      minutes.includes(m) &&\n      hours.includes(h) &&\n      daysOfMonth.includes(dom) &&\n      months.includes(mon) &&\n      daysOfWeek.includes(dow)\n    ) {\n      return candidate\n    }\n\n    // Advance by 1 minute\n    candidate.setTime(candidate.getTime() + 60_000)\n  }\n\n  throw new Error(`No next run found for cron \"${expression}\" within 1 year`)\n}\n\n// Retry config (inspired by OpenClaw's exponential backoff)\nconst MAX_RETRIES = 5\nconst RETRY_DELAYS = [30_000, 60_000, 300_000, 900_000, 3_600_000] // 30s, 1m, 5m, 15m, 60m\n\n/** Notification callback — injected by daemon to send alerts via channels */\nexport type CronNotifyCallback = (jobId: string, agent: string, error: string, consecutiveErrors: number) => Promise<void>\n\nexport class CronScheduler {\n  private jobs: Map<string, CronJobState> = new Map()\n  private timers: Map<string, ReturnType<typeof setTimeout>> = new Map()\n  private registry: AgentRegistry\n  private hooks?: HookRegistry\n  private runsDir: string\n  private lastRunFile: string\n  private running = false\n  private notifyCallback?: CronNotifyCallback\n  private log: (...args: unknown[]) => void\n\n  constructor(\n    config: DaemonConfig,\n    registry: AgentRegistry,\n    hooks?: HookRegistry,\n    log: (...args: unknown[]) => void = console.error.bind(console, \"[cron]\"),\n  ) {\n    this.registry = registry\n    this.hooks = hooks\n    this.log = log\n    this.runsDir = resolve(process.cwd(), \".agentx/cron/runs\")\n    this.lastRunFile = resolve(process.cwd(), \".agentx/cron/last-runs.json\")\n\n    for (const [id, def] of Object.entries(config.crons)) {\n      this.jobs.set(id, {\n        id,\n        enabled: def.enabled,\n        schedule: def.schedule,\n        timezone: def.timezone,\n        agent: def.agent,\n        prompt: def.prompt,\n        timeout: def.timeout,\n        model: def.model,\n        maxOutputTokens: def.maxOutputTokens,\n        onError: def.onError,\n        consecutiveErrors: 0,\n        totalRuns: 0,\n        totalFailures: 0,\n      })\n    }\n  }\n\n  /**\n   * Set a notification callback for failed crons.\n   * Called when onError is \"notify\" or after multiple consecutive failures.\n   */\n  setNotifyCallback(cb: CronNotifyCallback): void {\n    this.notifyCallback = cb\n  }\n\n  async start(): Promise<void> {\n    this.running = true\n\n    if (!existsSync(this.runsDir)) {\n      mkdirSync(this.runsDir, { recursive: true })\n    }\n\n    // Detect missed runs before scheduling\n    const missedRuns = this.detectMissedRuns()\n    if (missedRuns.length > 0) {\n      this.log(`Detected ${missedRuns.length} missed cron run(s) while daemon was down:`)\n      for (const { jobId, missedAt } of missedRuns) {\n        this.log(`  \"${jobId}\" should have run at ${missedAt.toISOString()}`)\n      }\n      // Execute missed runs (fire-and-forget, don't block startup)\n      this.executeMissedRuns(missedRuns).catch((e) => {\n        this.log(`Error executing missed runs: ${e.message}`)\n      })\n    }\n\n    for (const [id, job] of this.jobs) {\n      if (!job.enabled) {\n        this.log(`Job \"${id}\" is disabled, skipping`)\n        continue\n      }\n      this.scheduleNext(id)\n    }\n\n    this.log(`${this.jobs.size} cron job(s) loaded, ${Array.from(this.jobs.values()).filter((j) => j.enabled).length} enabled`)\n  }\n\n  async stop(): Promise<void> {\n    this.running = false\n    for (const timer of this.timers.values()) {\n      clearTimeout(timer)\n    }\n    this.timers.clear()\n\n    // Persist last run times for missed run detection on next start\n    this.saveLastRuns()\n  }\n\n  private scheduleNext(jobId: string): void {\n    const job = this.jobs.get(jobId)\n    if (!job || !job.enabled || !this.running) return\n\n    // Clear any existing timer\n    const existing = this.timers.get(jobId)\n    if (existing) clearTimeout(existing)\n\n    try {\n      const nextRun = getNextCronDate(job.schedule, new Date(), job.timezone)\n      job.nextRun = nextRun\n      job.retryPending = false\n      const delay = nextRun.getTime() - Date.now()\n\n      this.log(`Job \"${jobId}\" next run: ${nextRun.toISOString()} (in ${Math.round(delay / 1000)}s)`)\n\n      const timer = setTimeout(() => this.executeJob(jobId), delay)\n      this.timers.set(jobId, timer)\n    } catch (e: any) {\n      this.log(`Failed to schedule \"${jobId}\": ${e.message}`)\n    }\n  }\n\n  private scheduleRetry(jobId: string, attempt: number): void {\n    const job = this.jobs.get(jobId)\n    if (!job || !job.enabled || !this.running) return\n    if (attempt >= MAX_RETRIES) {\n      this.log(`Job \"${jobId}\" exhausted all ${MAX_RETRIES} retries, scheduling next regular run`)\n      this.scheduleNext(jobId)\n      return\n    }\n\n    const delay = RETRY_DELAYS[attempt] || RETRY_DELAYS[RETRY_DELAYS.length - 1]\n    job.retryPending = true\n\n    this.log(`Job \"${jobId}\" retry ${attempt + 1}/${MAX_RETRIES} in ${Math.round(delay / 1000)}s`)\n\n    const timer = setTimeout(() => this.executeJob(jobId, attempt + 1), delay)\n    this.timers.set(jobId, timer)\n  }\n\n  /**\n   * Phase 1 commit 6.d — record one cron-fire decision in the ledger\n   * when the source is enabled. Wrapped in try/catch so a ledger\n   * failure can never break cron dispatch — legacy stays authoritative\n   * until the 1c per-source promotion lands.\n   */\n  private recordCronDecisionInLedger(\n    jobId: string,\n    agentId: string,\n    firedAt: Date,\n    legacy: import(\"@/intent/divergence\").LegacyOutcome,\n  ): { eventId: string; decidedBy: string } | undefined {\n    if (getLedgerMode(\"cron\") === \"off\") return undefined\n    try {\n      const decision = recordCronDispatch(\n        getDefaultLedger(),\n        { jobId, agentId, firedAt },\n        JSON.stringify({ jobId, agentId, firedAt: firedAt.toISOString() }),\n        legacy,\n      )\n      if (decision.outcome === \"dispatched\") {\n        return { eventId: decision.eventId, decidedBy: decision.decidedBy }\n      }\n      return undefined\n    } catch (e: any) {\n      this.log(`[ledger] cron \"${jobId}\" record failed: ${e?.message ?? e}`)\n      return undefined\n    }\n  }\n\n  private async executeJob(jobId: string, retryAttempt: number = 0): Promise<void> {\n    const job = this.jobs.get(jobId)\n    if (!job || !this.running) return\n\n    const isRetry = retryAttempt > 0\n    // firedAt is captured here (rather than below at the original\n    // `startedAt` declaration) so the ledger event has a stable\n    // sourceEventId regardless of whether we record at the hook-block\n    // path or the dispatch path.\n    const firedAt = new Date()\n\n    // Pre-hook\n    if (this.hooks?.has(\"pre:cron-run\" as any)) {\n      const hookResult = await this.hooks.execute(\"pre:cron-run\" as any, {\n        event: \"pre:cron-run\" as any,\n        jobId,\n        agent: job.agent,\n        prompt: job.prompt,\n      })\n      if (hookResult.blocked) {\n        this.log(`Job \"${jobId}\" blocked by hook: ${hookResult.message}`)\n        this.recordCronDecisionInLedger(jobId, job.agent, firedAt, {\n          agentId: null, outcome: \"halted\",\n          reason: `pre-hook blocked: ${hookResult.message ?? \"\"}`.trim(),\n        })\n        this.scheduleNext(jobId)\n        return\n      }\n    }\n\n    this.log(`${isRetry ? `[retry ${retryAttempt}] ` : \"\"}Executing job \"${jobId}\" -> agent \"${job.agent}\"`)\n    const startedAt = firedAt\n    job.lastRun = startedAt\n    job.totalRuns++\n\n    // Phase 1 commit 6.d — record the dispatch decision before the\n    // (potentially long-running) registry.execute call. The returned\n    // intentRef threads through to registry.execute so it records a\n    // resolution on completion.\n    const intentRef = this.recordCronDecisionInLedger(jobId, job.agent, firedAt, {\n      agentId: job.agent, outcome: \"dispatched\", reason: isRetry ? `retry ${retryAttempt}` : null,\n    })\n\n    try {\n      const response = await this.registry.execute({\n        message: withOutputCap(job.prompt, job.maxOutputTokens),\n        agentId: job.agent,\n        model: job.model,\n        intentRef,\n        // chatId per-job so different cron jobs for the same agent don't\n        // collide in one \"default\" session. Without this, the marketing\n        // daily-brief and the marketing weekly-report cron share history,\n        // and one job's prompt context bleeds into the other.\n        context: { channel: \"cron\", chatId: `cron:${jobId}` },\n      })\n\n      const result: CronRunResult = {\n        jobId,\n        startedAt,\n        completedAt: new Date(),\n        success: !response.error,\n        response: response.content,\n        error: response.error,\n        duration: response.duration || Date.now() - startedAt.getTime(),\n        isRetry,\n        retryAttempt,\n      }\n\n      if (response.error) {\n        job.consecutiveErrors++\n        job.totalFailures++\n        job.lastError = response.error\n        this.log(`Job \"${jobId}\" failed (${job.consecutiveErrors} consecutive): ${response.error}`)\n\n        // Notify on failure\n        await this.notifyFailure(job, response.error)\n\n        if (job.onError.includes(\"disable\") && job.consecutiveErrors >= 3) {\n          job.enabled = false\n          this.log(`Job \"${jobId}\" disabled after ${job.consecutiveErrors} consecutive errors`)\n          // Persist to agentx.json so a daemon restart doesn't resurrect the\n          // broken cron (previously this was in-memory only — a repeatedly\n          // failing cron would keep burning money across restarts).\n          try {\n            const res = await applyConfigMutation(\n              (cfg) => setAtPath(cfg, `crons.${jobId}.enabled`, false),\n              { reload: false },\n            )\n            if (!res.success) {\n              this.log(`Failed to persist disable for \"${jobId}\": ${res.error}`)\n            }\n          } catch (e: any) {\n            this.log(`Failed to persist disable for \"${jobId}\": ${e.message}`)\n          }\n          await this.notifyDisabled(job)\n        }\n\n        // Retry\n        this.logRun(result)\n        this.scheduleRetry(jobId, retryAttempt)\n        return\n      } else {\n        // Success — reset error state\n        if (job.consecutiveErrors > 0) {\n          this.log(`Job \"${jobId}\" recovered after ${job.consecutiveErrors} failure(s)`)\n        }\n        job.consecutiveErrors = 0\n        job.lastSuccess = new Date()\n        job.lastError = undefined\n        job.retryPending = false\n        this.log(`Job \"${jobId}\" completed in ${result.duration}ms`)\n      }\n\n      // Log run\n      this.logRun(result)\n\n      // Post-hook\n      if (this.hooks?.has(\"post:cron-run\" as any)) {\n        await this.hooks.execute(\"post:cron-run\" as any, {\n          event: \"post:cron-run\" as any,\n          jobId,\n          success: result.success,\n          duration: result.duration,\n          error: result.error ? new Error(result.error) : undefined,\n        })\n      }\n    } catch (e: any) {\n      job.consecutiveErrors++\n      job.totalFailures++\n      job.lastError = e.message\n      this.log(`Job \"${jobId}\" threw: ${e.message}`)\n\n      await this.notifyFailure(job, e.message)\n      this.scheduleRetry(jobId, retryAttempt)\n      return\n    }\n\n    // Persist last run time\n    this.saveLastRuns()\n\n    // Schedule next regular run\n    this.scheduleNext(jobId)\n  }\n\n  // --- Missed run detection ---\n\n  /**\n   * Detect cron jobs that should have fired while the daemon was down.\n   * Compares saved last-run times against the cron schedule.\n   */\n  private detectMissedRuns(): Array<{ jobId: string; missedAt: Date }> {\n    const missed: Array<{ jobId: string; missedAt: Date }> = []\n\n    const lastRuns = this.loadLastRuns()\n    if (!lastRuns) return missed // First boot — no history\n\n    for (const [jobId, job] of this.jobs) {\n      if (!job.enabled) continue\n\n      const lastRunStr = lastRuns[jobId]\n      if (!lastRunStr) continue // Never ran before\n\n      const lastRun = new Date(lastRunStr)\n      try {\n        // What SHOULD the next run have been after the last recorded run?\n        const shouldHaveRun = getNextCronDate(job.schedule, lastRun, job.timezone)\n        if (shouldHaveRun.getTime() < Date.now()) {\n          missed.push({ jobId, missedAt: shouldHaveRun })\n        }\n      } catch {\n        // Invalid schedule — skip\n      }\n    }\n\n    return missed\n  }\n\n  /**\n   * Execute missed runs (catch-up). Runs sequentially to avoid overwhelming agents.\n   */\n  private async executeMissedRuns(missed: Array<{ jobId: string; missedAt: Date }>): Promise<void> {\n    for (const { jobId, missedAt } of missed) {\n      const job = this.jobs.get(jobId)\n      if (!job || !job.enabled) continue\n\n      this.log(`Running missed job \"${jobId}\" (was due at ${missedAt.toISOString()})`)\n\n      try {\n        const response = await this.registry.execute({\n          message: withOutputCap(\n            `[MISSED RUN — was scheduled for ${missedAt.toISOString()}]\\n\\n${job.prompt}`,\n            job.maxOutputTokens,\n          ),\n          agentId: job.agent,\n          context: { channel: \"cron\", chatId: `cron:${jobId}` },\n        })\n\n        const result: CronRunResult = {\n          jobId,\n          startedAt: new Date(),\n          completedAt: new Date(),\n          success: !response.error,\n          response: response.content,\n          error: response.error,\n          duration: response.duration || 0,\n          isRetry: false,\n        }\n\n        this.logRun(result)\n\n        if (response.error) {\n          this.log(`Missed job \"${jobId}\" failed: ${response.error}`)\n        } else {\n          this.log(`Missed job \"${jobId}\" completed`)\n          job.lastSuccess = new Date()\n        }\n        job.lastRun = new Date()\n        job.totalRuns++\n      } catch (e: any) {\n        this.log(`Missed job \"${jobId}\" threw: ${e.message}`)\n      }\n    }\n\n    this.saveLastRuns()\n  }\n\n  // --- Notification ---\n\n  private async notifyFailure(job: CronJobState, error: string): Promise<void> {\n    if (!job.onError.includes(\"notify\") && job.consecutiveErrors < 2) return\n    if (!this.notifyCallback) {\n      this.log(`[ALERT] Cron \"${job.id}\" failed (${job.consecutiveErrors}x): ${error.slice(0, 200)}`)\n      return\n    }\n\n    try {\n      await this.notifyCallback(job.id, job.agent, error, job.consecutiveErrors)\n    } catch {\n      // Don't fail on notification errors\n    }\n  }\n\n  private async notifyDisabled(job: CronJobState): Promise<void> {\n    if (!this.notifyCallback) {\n      this.log(`[ALERT] Cron \"${job.id}\" has been DISABLED after ${job.consecutiveErrors} consecutive failures`)\n      return\n    }\n\n    try {\n      await this.notifyCallback(\n        job.id,\n        job.agent,\n        `AUTO-DISABLED after ${job.consecutiveErrors} consecutive failures. Last error: ${job.lastError || \"unknown\"}`,\n        job.consecutiveErrors,\n      )\n    } catch {\n      // Don't fail on notification errors\n    }\n  }\n\n  // --- Persistence ---\n\n  private saveLastRuns(): void {\n    try {\n      const data: Record<string, string> = {}\n      for (const [id, job] of this.jobs) {\n        if (job.lastRun) data[id] = job.lastRun.toISOString()\n      }\n      const dir = resolve(process.cwd(), \".agentx/cron\")\n      if (!existsSync(dir)) mkdirSync(dir, { recursive: true })\n      writeFileSync(this.lastRunFile, JSON.stringify(data, null, 2))\n    } catch {\n      // Best-effort\n    }\n  }\n\n  private loadLastRuns(): Record<string, string> | null {\n    try {\n      if (!existsSync(this.lastRunFile)) return null\n      return JSON.parse(readFileSync(this.lastRunFile, \"utf-8\"))\n    } catch {\n      return null\n    }\n  }\n\n  private logRun(result: CronRunResult): void {\n    try {\n      const runDir = resolve(this.runsDir, result.jobId)\n      if (!existsSync(runDir)) {\n        mkdirSync(runDir, { recursive: true })\n      }\n\n      const filename = `${result.startedAt.toISOString().replace(/[:.]/g, \"-\")}.json`\n      writeFileSync(\n        resolve(runDir, filename),\n        JSON.stringify(result, null, 2),\n      )\n    } catch {\n      // Don't fail on logging errors\n    }\n  }\n\n  /**\n   * List all jobs and their status (including failure info).\n   */\n  list(): CronJobState[] {\n    return Array.from(this.jobs.values())\n  }\n\n  /**\n   * Get a health summary of cron jobs.\n   */\n  health(): { healthy: number; failing: number; disabled: number; missed: number; jobs: Array<{ id: string; status: string; consecutiveErrors: number; lastError?: string }> } {\n    const jobs = Array.from(this.jobs.values())\n    const missed = this.detectMissedRuns()\n\n    return {\n      healthy: jobs.filter(j => j.enabled && j.consecutiveErrors === 0).length,\n      failing: jobs.filter(j => j.enabled && j.consecutiveErrors > 0).length,\n      disabled: jobs.filter(j => !j.enabled).length,\n      missed: missed.length,\n      jobs: jobs.map(j => ({\n        id: j.id,\n        status: !j.enabled ? \"disabled\" : j.retryPending ? \"retrying\" : j.consecutiveErrors > 0 ? \"failing\" : \"healthy\",\n        consecutiveErrors: j.consecutiveErrors,\n        lastError: j.lastError,\n      })),\n    }\n  }\n}\n","import type { IntentSource } from \"./types\"\n\n// Mode-flag plumbing — Phase 1 commit 4 of the architectural rescue.\n//\n// The staged rollout in research-rescue-plan.md §7 needs three states:\n//\n//   off            ledger code is unreachable; legacy paths are authoritative.\n//                  This is the default and stays the default through 1a.\n//   shadow         decideAndCommit runs alongside the legacy paths on every\n//                  dispatch and records what *would* have happened. Legacy\n//                  remains authoritative; a divergence reporter (commit 5)\n//                  compares the two. The ≥7-day soak in 1b lives here.\n//   authoritative  ledger decision is the dispatch decision. Legacy paths\n//                  remain only as fallback gated by INTENT_LEDGER_FALLBACK\n//                  (commit 1c → 1d removes the legacy paths entirely).\n//\n// Mode is resolved per-source so 1c can flip sources one at a time\n// (gitlab → workflow → telegram → cron → mesh, ≥48h soak between each).\n//\n// This commit is plumbing only. No call site reads the mode yet —\n// commit 6 wires the readers behind the flag, defaulting to \"off\" so\n// production behaviour is unchanged at deploy time.\n\nexport type LedgerMode = \"off\" | \"shadow\" | \"authoritative\"\n\nconst VALID_MODES = [\"off\", \"shadow\", \"authoritative\"] as const satisfies readonly LedgerMode[]\n\n/** Per-source env-var names. Lifted to a constant so the call site (commit 6)\n *  doesn't need to construct strings, and so the test matrix can drive them\n *  by table rather than guessing the naming convention. */\nconst PER_SOURCE_ENV_VAR: Record<IntentSource, string> = {\n  telegram: \"INTENT_LEDGER_MODE_TELEGRAM\",\n  slack: \"INTENT_LEDGER_MODE_SLACK\",\n  whatsapp: \"INTENT_LEDGER_MODE_WHATSAPP\",\n  discord: \"INTENT_LEDGER_MODE_DISCORD\",\n  gitlab: \"INTENT_LEDGER_MODE_GITLAB\",\n  github: \"INTENT_LEDGER_MODE_GITHUB\",\n  workflow: \"INTENT_LEDGER_MODE_WORKFLOW\",\n  cron: \"INTENT_LEDGER_MODE_CRON\",\n  mesh: \"INTENT_LEDGER_MODE_MESH\",\n}\n\nconst GLOBAL_ENV_VAR = \"INTENT_LEDGER_MODE\"\n\n/**\n * Resolve the ledger mode for one source. Resolution order:\n *\n *   1. Per-source env var (e.g. INTENT_LEDGER_MODE_GITLAB)\n *   2. Global env var (INTENT_LEDGER_MODE)\n *   3. Default — \"off\"\n *\n * Invalid values at any level (typos, foreign strings) are ignored — that\n * level falls through to the next. Defaulting to \"off\" on garbage means an\n * operator typo never accidentally promotes a source to authoritative; the\n * cost is silence on misconfig, but the cost of the alternative\n * (mis-promoted source) is much higher in production.\n *\n * The accepted values are case-insensitive (\"Shadow\", \"SHADOW\", \"shadow\"\n * all parse) so config copied from a doc or shell history doesn't surprise.\n *\n * Read every call rather than cached. Per-dispatch overhead is one or two\n * `process.env` lookups — negligible — and runtime flips (operator SIGHUPs\n * the daemon and changes `EnvironmentFile=` on systemd) take effect on the\n * next event without a restart.\n */\nexport function getLedgerMode(\n  source: IntentSource,\n  env: NodeJS.ProcessEnv = process.env,\n): LedgerMode {\n  const perSource = parseLedgerMode(env[PER_SOURCE_ENV_VAR[source]])\n  if (perSource) return perSource\n  const global = parseLedgerMode(env[GLOBAL_ENV_VAR])\n  if (global) return global\n  return \"off\"\n}\n\n/** Parse a value into a LedgerMode, or return null for invalid / unset. */\nexport function parseLedgerMode(value: unknown): LedgerMode | null {\n  if (typeof value !== \"string\") return null\n  const normalized = value.trim().toLowerCase()\n  return (VALID_MODES as readonly string[]).includes(normalized)\n    ? (normalized as LedgerMode)\n    : null\n}\n\n/** Convenience: is this source consulting the ledger at all? Equivalent to\n *  `getLedgerMode(source) !== \"off\"`, named for callsite readability. */\nexport function isLedgerActive(\n  source: IntentSource,\n  env: NodeJS.ProcessEnv = process.env,\n): boolean {\n  return getLedgerMode(source, env) !== \"off\"\n}\n","import type { DispatchGovernance } from \"./decide\"\n\n// Daemon-level governance singleton — Phase 3 of the architectural rescue.\n//\n// `decideAndCommit` reads this when its caller doesn't pass an explicit\n// `governance` argument. The daemon initializes it at startup from the\n// `BusinessLayer.organization` instance, gated by the\n// `INTENT_PM_GATE_ENABLED` env var. When the var is unset (the deploy\n// default), the singleton stays undefined and no PM gate / canHandle\n// check fires — production behaviour is unchanged.\n//\n// This indirection keeps governance an opt-in concern: call sites and\n// helpers (`recordGitLabTargetDispatch`, `recordRouterDispatch`, etc.)\n// don't need to know about Organization. The daemon plumbs Organization\n// → DispatchGovernance once at startup; everything else stays generic.\n//\n// Tests reset between cases via `setDefaultGovernance(undefined)` to\n// avoid leakage from one test's fixture into another's behaviour.\n\nlet _governance: DispatchGovernance | undefined\n\n/** Set the process-wide default governance. Called once at daemon\n *  startup (or never, if INTENT_PM_GATE_ENABLED is off). */\nexport function setDefaultGovernance(g: DispatchGovernance | undefined): void {\n  _governance = g\n}\n\n/** Read the current default. `decideAndCommit` falls back to this when\n *  its caller didn't pass an explicit governance arg. Returns undefined\n *  in test contexts that haven't set anything (no governance fires). */\nexport function getDefaultGovernance(): DispatchGovernance | undefined {\n  return _governance\n}\n","import type { IntentLedger } from \"./ledger\"\nimport type { IntentDecision, IntentEventInput, IntentEvent } from \"./types\"\nimport { getDefaultGovernance } from \"./governance\"\n\n// decideAndCommit — Phase 1 of the architectural rescue.\n//\n// The single function every dispatch source will route through. Every event\n// entering the system flows: source-adapter → decideAndCommit → (optional\n// agent dispatch). The function's job is to:\n//\n//   1. Record the event idempotently (Inv-Idempotence)\n//   2. Consult the ledger for active-task state (Inv-ActiveTaskSafety)\n//   3. Ask the policy for a tentative decision\n//   4. Commit a single decision row to the ledger (Inv-NoSilentDrops)\n//\n// The four invariants are spelled out below and named so that Phase 2's\n// TLA+ spec can reference them by string. Tests in test/intent-decide.test.ts\n// cite these names in their assertion comments.\n//\n// **Phase 2 status**: three of the four invariants are formally verified\n// by TLC against `docs/architecture/DispatchSpec.tla` (410K distinct\n// states, depth 7, 0 violations as of 2026-04-29). The fourth\n// (Inv-Determinism) is a meta-property over traces, checked by code\n// review + the test in `intent-decide.test.ts`. See\n// `docs/architecture/dispatch-properties.md` for the full mapping\n// between code paths, invariants, and TLC results.\n//\n//   Inv-Idempotence       calling decideAndCommit twice with the same\n//                         (source, sourceEventId) and the same policy\n//                         produces one event row + one decision row;\n//                         the second call returns the row from the first.\n//   Inv-Determinism       given a fixed ledger snapshot, a fixed policy,\n//                         and a fixed clock, the resulting decision is a\n//                         pure function of the input event.\n//   Inv-ActiveTaskSafety  at most one decision with outcome=dispatched\n//                         that has not yet been resolved exists for any\n//                         (project, subject) at any point in the ledger.\n//   Inv-NoSilentDrops     every call to decideAndCommit appends exactly\n//                         one decision row to the ledger (or returns an\n//                         existing one under Inv-Idempotence). No code\n//                         path returns without a row visible in the ledger.\n//\n// What this commit does NOT do:\n//   - Wire decideAndCommit into any real call site (commit 6).\n//   - Add the mode flag (commit 4) — this function is reachable only from\n//     tests until commit 6 wires it up behind a flag that defaults off.\n//   - Read or expose the divergence reporter (commit 5).\n//   - Run async or call out to network. Policies are sync; if a real call\n//     site needs an LLM in the loop, that's a refactor for a later phase.\n\n/**\n * A pluggable dispatch policy. Each call site (channel router, workflow\n * dispatcher, gitlab handler, cron firing, mesh receiver) supplies its own\n * policy — the function below is purely the orchestration around the\n * policy's decision.\n *\n * The policy's `decidedBy` is the ledger's attribution string (\"who decided\n * this?\") and is what the ledger uses to scope idempotency: re-delivery of\n * the same event to the same `decidedBy` returns the existing row, while\n * the same event reaching a different `decidedBy` is a separate decision\n * (the chain-of-command case).\n */\nexport interface DispatchPolicy {\n  /** Stable attribution string. Examples: `\"channel-router\"`,\n   *  `\"workflow:gitlab-sdlc-loop\"`, `\"gitlab-handler\"`. Must be stable\n   *  across calls — the ledger uses it as the per-policy idempotency key. */\n  readonly decidedBy: string\n\n  /**\n   * Inspect the (already-recorded) event and return a tentative decision.\n   * Return `null` to mean \"I have no opinion\" — the caller will record a\n   * `halted` decision with reason `\"no policy match\"`.\n   *\n   * The policy MUST NOT write to the ledger directly. It MUST be a pure\n   * function of `event` plus any read-only context the caller closed over\n   * when constructing the policy. (Determinism — Inv-Determinism — depends\n   * on this.)\n   */\n  decide(event: IntentEvent): PolicyDecision | null\n}\n\n/** What a policy returns. The `outcome` set excludes `\"deduped\"` because\n *  dedup is the ledger's call, not the policy's. */\nexport interface PolicyDecision {\n  agentId: string | null\n  outcome: \"dispatched\" | \"halted\" | \"queued\"\n  reason: string | null\n}\n\n/**\n * Phase 3 — Org-chart governance hooks. Optional. When supplied,\n * decideAndCommit consults them AFTER the policy decides:\n *\n *   canHandle(agentId, project, intent)  returns false → halt the\n *     dispatch with reason \"org-chart: agent cannot handle\". Use to\n *     enforce per-agent capability constraints (Phase 5 will add\n *     typed capabilities; the v0 here is permissive).\n *\n *   pmFor(project)                       returns the agentId of the\n *     PM for `project`, or undefined when no PM is configured. When\n *     defined AND the policy decided \"dispatched\", the decision's\n *     `decidedBy` is rewritten to `pm:<pmId>` so the audit trail\n *     attributes the dispatch to the PM gate. Per the kickoff:\n *     \"a dispatch decision for (project, ...) where business.projects[].pm\n *     is set never resolves to an agent without going through the PM\n *     first (PM may rubber-stamp, but the decision row records\n *     decided_by='pm:pm-mtgl')\".\n *\n * The full async-PM gate (synchronously dispatch to the PM agent,\n * wait up to 60s for approval, fall back to escalation on timeout)\n * is a future-phase refactor. The v0 here is the paper-trail gate:\n * the decision row is attributed to the PM, but no real call-out\n * happens. This satisfies the kickoff's property and unblocks the\n * 1c per-source promotions.\n */\nexport interface DispatchGovernance {\n  canHandle?(agentId: string, project: string | null, intent: string | null): boolean\n  pmFor?(project: string | null): string | undefined\n  /** Phase 8 — capability-bounded security. Returns false when\n   *  dispatching `agentId` on `(project, subject)` would exceed the\n   *  agent's delegation-depth budget. Blocks cascade loops by\n   *  walking the ledger's prior decisions on the same slot. */\n  withinDelegationBudget?(agentId: string, project: string | null, subject: string | null): boolean\n}\n\n/**\n * Append-only dispatch primitive. Returns the canonical decision row —\n * either freshly written or recovered from a prior call (Inv-Idempotence).\n *\n * The whole call runs inside a single SQLite transaction so the lookup\n * (`getDecisionsForEvent` + `getActiveDecisionForSubject`) and the write\n * (`recordDecision`) are atomic with respect to the same database. This\n * matters under concurrent-call scenarios; in the single-process daemon\n * use case, better-sqlite3 already serialises writes so the transaction\n * is belt-and-braces. Adding it now means the call-site wiring (commit 6)\n * can call decideAndCommit from anywhere without worrying about races.\n */\nexport function decideAndCommit(\n  ledger: IntentLedger,\n  input: IntentEventInput,\n  policy: DispatchPolicy,\n  now: () => number = Date.now,\n  governance?: DispatchGovernance,\n): IntentDecision {\n  const tx = ledger.db.transaction((decidedAt: number): IntentDecision => {\n    // Step 1 — record the event. recordEvent is itself idempotent on\n    // (source, sourceEventId), so this is safe under re-delivery.\n    const event = ledger.recordEvent(input)\n\n    // Phase 3 governance: compute the EFFECTIVE decidedBy upfront so\n    // it threads through idempotency + recording. When a PM is\n    // configured for the project, the decision is attributed to the\n    // PM (pm:<id>) regardless of outcome — the PM is the gate, even\n    // for halts and queues. canHandle is a veto applied later (forces\n    // outcome=halted) but doesn't change decidedBy.\n    //\n    // Falls back to the daemon-level singleton (`getDefaultGovernance`)\n    // when the caller doesn't pass an explicit governance — this is\n    // the production path. Tests pass governance directly.\n    const gov = governance ?? getDefaultGovernance()\n    const pm = gov?.pmFor?.(event.project)\n    const effectiveDecidedBy = pm ? `pm:${pm}` : policy.decidedBy\n\n    // Step 2 — Inv-Idempotence. If this policy has already decided on this\n    // event, return that decision unchanged. Two callers who race the same\n    // event-policy pair are reduced to a single decision row.\n    const prior = ledger\n      .getDecisionsForEvent(event.id)\n      .find((d) => d.decidedBy === effectiveDecidedBy)\n    if (prior) return prior\n\n    // Step 3 — Inv-ActiveTaskSafety. If a dispatched-and-unresolved\n    // decision already exists for (project, subject), this event must\n    // dedupe. The dedup outcome is ledger-managed; the policy never sees\n    // a chance to override it.\n    const active = ledger.getActiveDecisionForSubject(event.project, event.subject)\n    if (active) {\n      const decision: IntentDecision = {\n        eventId: event.id,\n        decidedAt,\n        decidedBy: effectiveDecidedBy,\n        agentId: null,\n        outcome: \"deduped\",\n        reason: `active dispatch in flight: ${active.decidedBy} → ${active.agentId ?? \"?\"}`,\n      }\n      ledger.recordDecision(decision)\n      return decision\n    }\n\n    // Step 4 — consult the policy. A null result is a halt with explicit\n    // reason rather than a silent drop (Inv-NoSilentDrops). A halted /\n    // queued / dispatched policy decision flows through unchanged.\n    const policyResult = policy.decide(event)\n    let agentId: string | null = policyResult ? policyResult.agentId : null\n    let outcome: \"dispatched\" | \"halted\" | \"queued\" = policyResult ? policyResult.outcome : \"halted\"\n    let reason: string | null = policyResult ? policyResult.reason : \"no policy match\"\n\n    // Step 5 — canHandle veto. Dispatches to agents the org chart says\n    // can't handle the event get forced to halted.\n    if (gov?.canHandle && outcome === \"dispatched\" && agentId) {\n      const allowed = gov.canHandle(agentId, event.project, event.intent)\n      if (!allowed) {\n        const blocked = agentId\n        agentId = null\n        outcome = \"halted\"\n        reason = `org-chart: agent \"${blocked}\" cannot handle (${event.project ?? \"no-project\"}/${event.intent ?? \"no-intent\"})`\n      }\n    }\n\n    // Step 5b — Phase 8 delegation-depth check. Walks the ledger's\n    // prior decisions on (project, subject) and refuses dispatches\n    // that would push the chain past the agent's\n    // `maxDelegationDepth`. Prevents cascade loops where A → B → A → ...\n    // blows past sane chain depth.\n    if (gov?.withinDelegationBudget && outcome === \"dispatched\" && agentId) {\n      if (!gov.withinDelegationBudget(agentId, event.project, event.subject)) {\n        const blocked = agentId\n        agentId = null\n        outcome = \"halted\"\n        reason = `delegation-budget: agent \"${blocked}\" depth-limit exceeded on ${event.project ?? \"?\"}/${event.subject ?? \"?\"}`\n      }\n    }\n\n    // Annotate the reason when PM-gate took effect, so the audit trail\n    // distinguishes pm-gated dispatches from regular ones.\n    if (pm && outcome === \"dispatched\" && agentId) {\n      reason = reason\n        ? `${reason} (pm-gate: rubber-stamped by ${pm})`\n        : `pm-gate: rubber-stamped by ${pm}`\n    }\n\n    const decision: IntentDecision = {\n      eventId: event.id,\n      decidedAt,\n      decidedBy: effectiveDecidedBy,\n      agentId,\n      outcome,\n      reason,\n    }\n    ledger.recordDecision(decision)\n    return decision\n  })\n\n  return tx(now())\n}\n","import { logger } from \"../utils/logger\"\nimport type { IntentLedger } from \"./ledger\"\nimport { newEventId } from \"./ulid\"\nimport type {\n  IntentDecision,\n  IntentDivergence,\n  IntentOutcomeKind,\n  IntentSource,\n} from \"./types\"\n\n// Divergence reporter — Phase 1 commit 5 of the architectural rescue.\n//\n// During shadow mode (1b in research-rescue-plan.md §7), every dispatch\n// runs through both the legacy path and decideAndCommit. The legacy path\n// remains authoritative; the ledger's decision is recorded but does not\n// drive behaviour. The reporter compares the two and:\n//\n//   - on agreement: no-op (the soak's success criterion is \"zero\n//     divergences for ≥7 days\" — quiet operation IS the signal).\n//   - on mismatch: log a structured warning AND write a row to\n//     intent_divergences so the soak dashboard has a queryable surface.\n//\n// The shape of \"the legacy outcome\" is deliberately structural rather\n// than tied to any one source's existing output type — that lets the\n// commit-6 wiring adapt each call site (channel-router's `Routed`, the\n// workflow dispatcher's `DispatchResult`, etc.) into a common\n// LegacyOutcome at the comparison boundary instead of carrying source-\n// specific shapes through the reporter.\n\n/** Minimal projection of a legacy dispatch path's outcome — only the\n *  fields we compare against the ledger decision. */\nexport interface LegacyOutcome {\n  agentId: string | null\n  outcome: IntentOutcomeKind\n  /** Optional human-readable reason; recorded for forensics, never\n   *  compared. (Legacy reasons and ledger reasons phrase the same\n   *  decision differently — comparing them would produce noise.) */\n  reason?: string | null\n}\n\n/**\n * Compare a ledger decision against the legacy path's outcome. On mismatch,\n * append a divergence row and emit a `[ledger-divergence]` log line.\n * Returns `true` when a divergence was recorded, `false` on agreement.\n *\n * Comparison is structural on the load-bearing fields: `outcome` and\n * `agentId`. `reason` strings differ harmlessly between paths and are\n * forensic-only — comparing them would produce noise that drowns out\n * the actual semantic mismatches we care about.\n */\nexport function reportDivergence(\n  ledger: IntentLedger,\n  source: IntentSource,\n  ledgerDecision: IntentDecision,\n  legacy: LegacyOutcome,\n  now: () => number = Date.now,\n): boolean {\n  if (decisionsAgree(ledgerDecision, legacy)) return false\n\n  const ts = now()\n  const record: IntentDivergence = {\n    id: newEventId(ts),\n    ts,\n    source,\n    eventId: ledgerDecision.eventId,\n    decidedBy: ledgerDecision.decidedBy,\n    ledgerAgentId: ledgerDecision.agentId,\n    ledgerOutcome: ledgerDecision.outcome,\n    ledgerReason: ledgerDecision.reason,\n    legacyAgentId: legacy.agentId,\n    legacyOutcome: legacy.outcome,\n    legacyReason: legacy.reason ?? null,\n  }\n  ledger.recordDivergence(record)\n\n  // Single-line structured log so journalctl + grep are sufficient triage\n  // tools during the soak (commit 8 adds a UI; until then, journal is it).\n  logger.warn(\n    `[ledger-divergence] source=${source} ` +\n      `event=${ledgerDecision.eventId} ` +\n      `decided_by=${ledgerDecision.decidedBy} ` +\n      `ledger=${ledgerDecision.outcome}/${ledgerDecision.agentId ?? \"null\"} ` +\n      `legacy=${legacy.outcome}/${legacy.agentId ?? \"null\"}`,\n  )\n  return true\n}\n\n/** Two outcomes agree iff they pick the same target with the same outcome\n *  kind. Reasons (free-form) are not part of agreement. */\nexport function decisionsAgree(\n  ledgerDecision: IntentDecision,\n  legacy: LegacyOutcome,\n): boolean {\n  return (\n    ledgerDecision.outcome === legacy.outcome &&\n    ledgerDecision.agentId === legacy.agentId\n  )\n}\n","import type { IntentLedger } from \"../ledger\"\nimport { decideAndCommit, type DispatchPolicy } from \"../decide\"\nimport { reportDivergence, type LegacyOutcome } from \"../divergence\"\nimport type { IntentDecision, IntentEventInput } from \"../types\"\n\n// Source adapter — cron scheduler. Phase 1 commit 6.d.\n//\n// Cron is the cleanest 1:1 dispatch source: one fire → one agent. The\n// scheduler's `executeJob(jobId)` is the dispatch entry point. We\n// instrument the two decision branches (hook-blocked vs hook-approved)\n// and pass the legacy outcome to a pass-through policy.\n\nexport interface CronJobProjection {\n  jobId: string\n  agentId: string\n  /** When the job fired (used as part of the ULID-friendly sourceEventId). */\n  firedAt: Date\n}\n\n/** Build the IntentEventInput for one cron fire. sourceEventId is\n *  per-(jobId, firedAt) so concurrent re-fires (shouldn't happen but)\n *  collapse via idempotency. Subject scopes active-task safety to one\n *  fire-in-flight per job — but project=null disables Inv-ActiveTaskSafety,\n *  so successive fires of the same job both dispatch (matches legacy). */\nexport function buildCronEventInput(\n  proj: CronJobProjection,\n  rawJson: string,\n  now: () => number = Date.now,\n): IntentEventInput {\n  return {\n    ts: now(),\n    source: \"cron\",\n    sourceEventId: `${proj.jobId}:${proj.firedAt.getTime()}`,\n    project: null,\n    subject: `cron:${proj.jobId}`,\n    intent: \"cron.fired\",\n    rawJson,\n  }\n}\n\n/** Pass-through policy. Same shape as router/workflow: divergences come\n *  from ledger MECHANICS, not policy disagreement. */\nexport function buildCronPolicyFromLegacy(legacy: LegacyOutcome): DispatchPolicy {\n  return {\n    decidedBy: \"cron-scheduler\",\n    decide: () => ({\n      agentId: legacy.agentId,\n      outcome: legacy.outcome === \"deduped\" ? \"halted\" : legacy.outcome,\n      reason:\n        legacy.outcome === \"deduped\"\n          ? `legacy-dedup: ${legacy.reason ?? \"\"}`.trim()\n          : legacy.reason ?? null,\n    }),\n  }\n}\n\nexport function recordCronDispatch(\n  ledger: IntentLedger,\n  proj: CronJobProjection,\n  rawJson: string,\n  legacyOutcome: LegacyOutcome,\n  now: () => number = Date.now,\n): IntentDecision {\n  const eventInput = buildCronEventInput(proj, rawJson, now)\n  const policy = buildCronPolicyFromLegacy(legacyOutcome)\n  const ledgerDecision = decideAndCommit(ledger, eventInput, policy, now)\n  reportDivergence(ledger, \"cron\", ledgerDecision, legacyOutcome, now)\n  return ledgerDecision\n}\n"],"mappings":"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","names":["writeFileSync","mkdirSync","existsSync","readFileSync","resolve","VALID_MODES","PER_SOURCE_ENV_VAR","GLOBAL_ENV_VAR","getLedgerMode","source","env","perSource","parseLedgerMode","global","value","normalized","_governance","setDefaultGovernance","g","getDefaultGovernance","decideAndCommit","ledger","input","policy","now","governance","decidedAt","event","gov","getDefaultGovernance","pm","effectiveDecidedBy","prior","d","active","decision","policyResult","agentId","outcome","reason","blocked","reportDivergence","ledger","source","ledgerDecision","legacy","now","decisionsAgree","ts","record","newEventId","logger","buildCronEventInput","proj","rawJson","now","buildCronPolicyFromLegacy","legacy","recordCronDispatch","ledger","legacyOutcome","eventInput","policy","ledgerDecision","decideAndCommit","reportDivergence","withOutputCap","prompt","maxOutputTokens","approxChars","parseCronField","field","min","max","values","part","i","range","stepStr","step","start","a","b","getNextCronDate","expression","after","timezone","fields","minutes","hours","daysOfMonth","months","daysOfWeek","fmt","candidate","limit","parts","get","type","p","m","h","dom","mon","dow","MAX_RETRIES","RETRY_DELAYS","CronScheduler","config","registry","hooks","log","resolve","id","def","cb","existsSync","mkdirSync","missedRuns","jobId","missedAt","e","job","j","timer","existing","nextRun","delay","attempt","agentId","firedAt","legacy","getLedgerMode","decision","recordCronDispatch","getDefaultLedger","retryAttempt","isRetry","hookResult","startedAt","intentRef","response","result","res","applyConfigMutation","cfg","setAtPath","missed","lastRuns","lastRunStr","lastRun","shouldHaveRun","error","data","dir","writeFileSync","readFileSync","runDir","filename","jobs"]}