@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/dm-freshness-metrics.d.ts

@@ -1,14 +1,15 @@
 import type Database from "better-sqlite3";
 /**
  * STAGE-C-DM-FRESHNESS-PLAN §Task 4 — "is the user asking about recent
- * activity?" detector. The bilingual list mirrors the trigger phrases
- * exposed in `agent-assets/task-flows/message.received.dm.md`'s
- * "Recent activity — refetch on demand" subsection.
+ * activity?" detector. Mirrors the English trigger phrases exposed in
+ * `agent-assets/task-flows/message.received.dm.md`'s "Recent activity
+ * — refetch on demand" subsection; equivalents in other languages are
+ * handled by the LLM rather than by this heuristic.
  *
  * Match is intentionally permissive: it powers the refetch-hit rate
  * metric (Task 4 §Acceptance threshold), not gating logic. False
- * positives slightly under-count refetch hits (the agent legitimately
- * decides a question is not about activity) but never cause harm.
+ * negatives on non-English DMs slightly under-count refetch hits in
+ * non-English cohorts but never cause harm.
  */
 export declare const RECENT_ACTIVITY_TRIGGER_RE: RegExp;
 export declare function matchesRecentActivityTrigger(content: string): boolean;
@@ -70,4 +71,3 @@ export interface DmFreshnessAggregate {
  * rows over 7 days at the maintainer's traffic) so this is fine.
  */
 export declare function computeDmFreshnessAggregate(db: Database.Database, windowDays?: number): DmFreshnessAggregate;
-//# sourceMappingURL=dm-freshness-metrics.d.ts.map

package/dist/core/dm-freshness-metrics.js

@@ -1,16 +1,17 @@
 import { formatSqliteDatetime } from "@aitne/shared";
 /**
  * STAGE-C-DM-FRESHNESS-PLAN §Task 4 — "is the user asking about recent
- * activity?" detector. The bilingual list mirrors the trigger phrases
- * exposed in `agent-assets/task-flows/message.received.dm.md`'s
- * "Recent activity — refetch on demand" subsection.
+ * activity?" detector. Mirrors the English trigger phrases exposed in
+ * `agent-assets/task-flows/message.received.dm.md`'s "Recent activity
+ * — refetch on demand" subsection; equivalents in other languages are
+ * handled by the LLM rather than by this heuristic.
  *
  * Match is intentionally permissive: it powers the refetch-hit rate
  * metric (Task 4 §Acceptance threshold), not gating logic. False
- * positives slightly under-count refetch hits (the agent legitimately
- * decides a question is not about activity) but never cause harm.
+ * negatives on non-English DMs slightly under-count refetch hits in
+ * non-English cohorts but never cause harm.
  */
-export const RECENT_ACTIVITY_TRIGGER_RE = /(what have you been up to|did anything come in|anything new since|ここ最近|さっき|直近|ここ\s*\d+\s*分|何かあった)/i;
+export const RECENT_ACTIVITY_TRIGGER_RE = /(what have you been up to|did anything come in|anything new since|anything happen|in the (?:last|past) \d+\s*min)/i;
 export function matchesRecentActivityTrigger(content) {
     return RECENT_ACTIVITY_TRIGGER_RE.test(content);
 }
@@ -135,4 +136,3 @@ function percentile(sortedAsc, p) {
     const rank = Math.min(sortedAsc.length - 1, Math.max(0, Math.ceil(p * sortedAsc.length) - 1));
     return sortedAsc[rank];
 }
-//# sourceMappingURL=dm-freshness-metrics.js.map

package/dist/core/dm-token-router.d.ts

@@ -0,0 +1,58 @@
+/**
+ * DM-token router — BROWSER_TASK_REDESIGN_PLAN.md §14.11 Q#6.
+ *
+ * Pure decision module shared between the messaging adapter's inbound
+ * `!~xxxxxxxx` classifier and any future programmatic caller that
+ * needs to know "given a token reply, which handler owns it?".
+ *
+ * Two stores share the `!~xxxxxxxx` envelope on the same primary
+ * channels:
+ *
+ *  - B-4 purchase tokens (`browser_automation_purchase_tokens`)
+ *  - lite-final-confirm tokens (`browser_task_final_confirm_tokens`)
+ *
+ * Both jtis are uuid v4 so a colliding-raw-string match is bounded by
+ * uuid uniqueness — but the surface still has to deterministically
+ * resolve the rare case where both stores return a row for the same
+ * raw inbound. This module's `decideTokenReplyRoute` is the single
+ * source of truth for that decision:
+ *
+ *   - exactly one row → route to that handler
+ *   - both rows present → older `issuedAt` wins (deterministic;
+ *     prevents the surface from oscillating between handlers on retries)
+ *   - neither → `none` (caller fans strict-cancel-on-non-token-reply
+ *     to both handlers if wired)
+ *
+ * Pure — no DB, no clock. 100% covered per §13 testing table extension.
+ */
+/** The minimal row shape the router needs from either store. Both
+ *  `PurchaseTokenRow` and `LiteFinalConfirmTokenRow` carry these fields
+ *  with identical semantics so the router can read either. */
+export interface TokenIssueRowView {
+    issuedAt: number;
+}
+export type TokenReplyRoute = {
+    kind: "none";
+} | {
+    kind: "purchase";
+} | {
+    kind: "lite_final_confirm";
+};
+/**
+ * Decide which handler should consume an inbound `!~xxxxxxxx` reply.
+ *
+ * The caller passes the result of `purchaseHandler.lookupByRaw(token)`
+ * and `finalConfirmHandler.lookupByRaw(token)` (either may be null when
+ * the corresponding handler isn't wired OR when the store has no
+ * matching row). The router does NOT call into either store — it is
+ * pure decision logic over the two views.
+ *
+ * Tie-break: when both rows exist, prefer the older `issuedAt`. If the
+ * two are tied to the millisecond (cosmically unlikely), prefer
+ * `purchase` — picking a stable left-hand side keeps the decision
+ * reproducible without an external nonce.
+ */
+export declare function decideTokenReplyRoute(input: {
+    purchaseRow: TokenIssueRowView | null;
+    liteRow: TokenIssueRowView | null;
+}): TokenReplyRoute;

package/dist/core/dm-token-router.js

@@ -0,0 +1,58 @@
+/**
+ * DM-token router — BROWSER_TASK_REDESIGN_PLAN.md §14.11 Q#6.
+ *
+ * Pure decision module shared between the messaging adapter's inbound
+ * `!~xxxxxxxx` classifier and any future programmatic caller that
+ * needs to know "given a token reply, which handler owns it?".
+ *
+ * Two stores share the `!~xxxxxxxx` envelope on the same primary
+ * channels:
+ *
+ *  - B-4 purchase tokens (`browser_automation_purchase_tokens`)
+ *  - lite-final-confirm tokens (`browser_task_final_confirm_tokens`)
+ *
+ * Both jtis are uuid v4 so a colliding-raw-string match is bounded by
+ * uuid uniqueness — but the surface still has to deterministically
+ * resolve the rare case where both stores return a row for the same
+ * raw inbound. This module's `decideTokenReplyRoute` is the single
+ * source of truth for that decision:
+ *
+ *   - exactly one row → route to that handler
+ *   - both rows present → older `issuedAt` wins (deterministic;
+ *     prevents the surface from oscillating between handlers on retries)
+ *   - neither → `none` (caller fans strict-cancel-on-non-token-reply
+ *     to both handlers if wired)
+ *
+ * Pure — no DB, no clock. 100% covered per §13 testing table extension.
+ */
+/**
+ * Decide which handler should consume an inbound `!~xxxxxxxx` reply.
+ *
+ * The caller passes the result of `purchaseHandler.lookupByRaw(token)`
+ * and `finalConfirmHandler.lookupByRaw(token)` (either may be null when
+ * the corresponding handler isn't wired OR when the store has no
+ * matching row). The router does NOT call into either store — it is
+ * pure decision logic over the two views.
+ *
+ * Tie-break: when both rows exist, prefer the older `issuedAt`. If the
+ * two are tied to the millisecond (cosmically unlikely), prefer
+ * `purchase` — picking a stable left-hand side keeps the decision
+ * reproducible without an external nonce.
+ */
+export function decideTokenReplyRoute(input) {
+    const { purchaseRow, liteRow } = input;
+    if (!purchaseRow && !liteRow)
+        return { kind: "none" };
+    if (purchaseRow && !liteRow)
+        return { kind: "purchase" };
+    if (liteRow && !purchaseRow)
+        return { kind: "lite_final_confirm" };
+    // Both present — deterministic tie-break by oldest issuance, with
+    // `purchase` winning a hard tie (both rows would represent a
+    // sub-millisecond collision on a 40-bit shared token space — already
+    // implausible; the rule preserves replayability for the case it
+    // happens anyway).
+    return purchaseRow.issuedAt <= liteRow.issuedAt
+        ? { kind: "purchase" }
+        : { kind: "lite_final_confirm" };
+}

package/dist/core/docs/citation-validator.d.ts

@@ -70,4 +70,3 @@ export declare function logInvalidCitations(db: Database.Database, result: Pick<
     sessionId?: number | null;
     turnNumber?: number | null;
 }): void;
-//# sourceMappingURL=citation-validator.d.ts.map

package/dist/core/docs/citation-validator.js

@@ -192,4 +192,3 @@ export function logInvalidCitations(db, result, context = {}) {
         logger.debug({ err }, "Failed to log qa_invalid_citation audit row");
     }
 }
-//# sourceMappingURL=citation-validator.js.map

package/dist/core/docs/extract-terms.d.ts

@@ -75,4 +75,3 @@ export declare function iterateHeadings(body: string): HeadingRef[];
  * heading text itself is searchable as a `term`).
  */
 export declare function extractTerms(fm: DocsFrontmatter, body: string): ExtractedTerm[];
-//# sourceMappingURL=extract-terms.d.ts.map

package/dist/core/docs/extract-terms.js

@@ -144,4 +144,3 @@ function collectSectionLead(lines, start, end) {
         return joined;
     return joined.slice(0, LEADING_PARAGRAPH_MAX_LEN);
 }
-//# sourceMappingURL=extract-terms.js.map

package/dist/core/docs/indexer.d.ts

@@ -101,4 +101,3 @@ export declare const _internal: {
     joinTokens: typeof joinTokens;
 };
 export {};
-//# sourceMappingURL=indexer.d.ts.map

package/dist/core/docs/indexer.js

@@ -337,4 +337,3 @@ async function listMarkdownFiles(root) {
 // Small re-export so tests that need to compose a path-style slug do not
 // need to re-implement the OS-separator rewrite.
 export const _internal = { sep, joinTokens };
-//# sourceMappingURL=indexer.js.map

package/dist/core/drift-effects.d.ts

@@ -27,4 +27,3 @@ export declare const __driftEffectsTestExports: {
     TODAY_REFRESH_AUTO_AT_KEY: string;
     TODAY_REFRESH_PENDING_KEY: string;
 };
-//# sourceMappingURL=drift-effects.d.ts.map

package/dist/core/drift-effects.js

@@ -349,9 +349,13 @@ function enqueueTodayRefresh(db, params) {
     // it. Drift can fire from CalendarPoller, the reconcile route, or a
     // post-morning flush; the prefix encodes which.
     const correlationId = `drift:${params.integration}:${params.windowKey}:${params.requestedAt}`;
+    const driftInstruction = "Refresh today.md User Schedule after calendar drift.";
     db.prepare(`INSERT INTO agent_schedule
-       (scheduled_for, task_type, task_description, task_context, correlation_id, model, status)
-     VALUES (?, 'wake', ?, ?, ?, NULL, 'pending')`).run(formatSqliteDatetime(params.scheduledFor), "Refresh today.md User Schedule after calendar drift.", JSON.stringify({
+       (scheduled_for, task_type, task_description, task_prompt, task_context, correlation_id, model, status)
+     VALUES (?, 'wake', ?, ?, ?, ?, NULL, 'pending')`).run(formatSqliteDatetime(params.scheduledFor), 
+    // task_description (label) doubles as task_prompt (agent instruction);
+    // routing is via task_context.routine = "today_refresh".
+    driftInstruction, driftInstruction, JSON.stringify({
         routine: "today_refresh",
         source: "integration_drift",
         reason: params.reason,
@@ -381,4 +385,3 @@ export const __driftEffectsTestExports = {
     TODAY_REFRESH_AUTO_AT_KEY,
     TODAY_REFRESH_PENDING_KEY,
 };
-//# sourceMappingURL=drift-effects.js.map

package/dist/core/evening-review-verify.d.ts

@@ -0,0 +1,163 @@
+import type Database from "better-sqlite3";
+/** envelope seeded in `process_backend_config` for routine.evening_review */
+export declare const EVENING_REVIEW_ENVELOPE_BUDGET_USD = 1;
+export declare const EVENING_REVIEW_ENVELOPE_MAX_TURNS = 50;
+/** danger threshold — half of cap. Slim shape sits well below this. */
+export declare const ENVELOPE_DANGER_FRACTION = 0.5;
+export type CheckStatus = "pass" | "warn" | "fail";
+export interface CheckResult<TData = unknown> {
+    id: string;
+    label: string;
+    status: CheckStatus;
+    detail: string;
+    hint?: string;
+    data: TData;
+}
+export type EveningReviewSlimdownCheck = CheckResult<CronFreshnessData> | CheckResult<TokenEnvelopeData> | CheckResult<NotifyLoadData> | CheckResult<NotifyInvocationsData>;
+export interface VerifyReport {
+    checks: EveningReviewSlimdownCheck[];
+    summary: {
+        total: number;
+        passed: number;
+        warned: number;
+        failed: number;
+        windowDays: number;
+        installAgeDays: number;
+        generatedAt: string;
+    };
+}
+export interface RunChecksDeps {
+    db: Database.Database;
+    contextDir: string;
+    /** caller-clamped window for time-bounded checks (default 7) */
+    windowDays?: number;
+    /** Override for testing. Defaults to `new Date()`. */
+    now?: () => Date;
+}
+export interface RulebookInspection {
+    state: "absent" | "empty" | "no_headings" | "active" | "unreadable";
+    predicateActive: boolean | null;
+    headingCount: number;
+}
+export declare function runEveningReviewSlimdownChecks(deps: RunChecksDeps): VerifyReport;
+export interface CronFreshnessData {
+    windowDays: number;
+    daysWithRow: number;
+    daysMissing: string[];
+    failedRows: number;
+    lastRunAt: string | null;
+    lastRunResult: string | null;
+}
+export declare function checkCronAuditFreshness(db: Database.Database, opts: {
+    windowDays: number;
+    installAgeDays: number;
+    now: Date;
+}): CheckResult<CronFreshnessData>;
+export interface TokenEnvelopeData {
+    windowDays: number;
+    sessions: number;
+    avgInputTokens: number | null;
+    maxInputTokens: number | null;
+    avgOutputTokens: number | null;
+    maxOutputTokens: number | null;
+    avgCacheReadTokens: number | null;
+    avgCostUsd: number;
+    maxCostUsd: number;
+    avgNumTurns: number | null;
+    maxNumTurns: number | null;
+    envelopeBudgetUsd: number;
+    envelopeMaxTurns: number;
+}
+export declare function checkEveningReviewTokenEnvelope(db: Database.Database, opts: {
+    windowDays: number;
+}): CheckResult<TokenEnvelopeData>;
+export interface NotifyLoadData {
+    contextDir: string;
+    rulebookPath: string;
+    rulebookState: RulebookInspection["state"];
+    rulebookHeadingCount: number;
+    predicateActive: boolean | null;
+    expectedSkillCount: number;
+    resolvedManifest: string[];
+}
+export declare function checkConditionalNotifyLoad(opts: {
+    contextDir: string;
+    rulebook: RulebookInspection;
+}): CheckResult<NotifyLoadData>;
+export interface NotifyInvocationsData {
+    windowDays: number;
+    sessions: number;
+    sessionsWithNotify: number;
+    totalNotifies: number;
+    rulebookActive: boolean | null;
+    samples: Array<{
+        id: number;
+        startedAt: string;
+        completedAt: string | null;
+        notifyCount: number;
+    }>;
+}
+export declare function checkNotifyInvocations30d(db: Database.Database, opts: {
+    installAgeDays: number;
+    rulebookActive: boolean | null;
+}): CheckResult<NotifyInvocationsData>;
+/**
+ * Pre-read inspection of `policies/routines/evening.md` that surfaces detail the
+ * boolean predicate doesn't expose (heading count, indeterminate state).
+ *
+ * The daemon's predicate (`eveningRulebookIsActive`) is canonical and
+ * the caller overlays its boolean answer on top of this inspection's
+ * state — see `runEveningReviewSlimdownChecks`. The split exists because
+ * the predicate intentionally collapses unreadable / absent / empty
+ * into a single `false`, which is the right runtime answer but loses
+ * the diagnostic detail the verify report needs.
+ */
+export declare function inspectRulebook(contextDir: string): RulebookInspection;
+/**
+ * Best-effort install age proxy: the oldest agent_actions row.
+ *
+ * Returns the floor in agent-days, capped at 365 so a long-running
+ * install doesn't widen the verification window past Phase 4's intent.
+ * Returns 1 when the table is empty (a fresh install has no history;
+ * clamping prevents "0-day window" arithmetic downstream) — that 1
+ * also drives the fresh-install softening in the cron-freshness check.
+ */
+export declare function readInstallAgeDays(db: Database.Database): number;
+/**
+ * Returns YYYY-MM-DD strings from `now - windowDays + 1` up to `now` in
+ * the host's local timezone. Used to enumerate which agent-days the
+ * cron freshness check expects a row for.
+ */
+export declare function expectedDaySet(now: Date, windowDays: number): string[];
+/**
+ * Resolve the context directory the same way the daemon's
+ * `getContextDir(config, db)` does, but reading from the raw `settings`
+ * table so the CLI doesn't need to construct a full AgentConfig.
+ *
+ * The three-branch contract mirrors `config.ts:getContextDir` exactly:
+ *
+ *   1. plain mode → `<dataDir>/context`
+ *   2. obsidian mode + configured `primaryVaultPath` + NOT degraded → the
+ *      configured vault path
+ *   3. obsidian mode + degraded (vault currently unreachable) → fall
+ *      back to `<dataDir>/context`, matching what the daemon's runtime
+ *      actually reads from while degraded
+ *
+ * Without (3) the verify CLI would evaluate the rulebook predicate
+ * against an unreadable vault path while the daemon evaluates it against
+ * the fallback — silently inverting the §3.5 cross-backend parity claim
+ * during exactly the time a verify report is most likely to be run
+ * (operator investigating why the agent is acting strangely).
+ *
+ * Settings values are JSON-encoded in the `settings` table. Corrupt /
+ * unparseable JSON is treated as "not configured" rather than throwing —
+ * a verify report should never fail because a single setting row is
+ * malformed; the daemon's `parseJsonOrDefault` has the same posture.
+ *
+ * Tilde-expansion (`~/Foo`) of `primaryVaultPath` matches
+ * `normalizeRuntimeSettings` in `config.ts`. In practice the setup
+ * wizard stores absolute paths, but this defends against a manually-set
+ * value in the settings table (and against any future writer that
+ * forgets to expand).
+ */
+export declare function resolveContextDirFromDb(db: Database.Database, dataDir: string): string;