@aitne/daemon 0.1.8 → 0.1.10

package/dist/core/context-vault-aliases.js

@@ -0,0 +1,253 @@
+/**
+ * Legacy vault-path alias resolver (CONTEXT_VAULT_REDESIGN_PLAN.md
+ * §7.3 + §14.3 + v4 V8).
+ *
+ * **Why it exists.** The vault restructure moves files from
+ * `user/` / `rules/` / `routines/` / `projects/` / `daily/` / etc. into
+ * six class directories (`identity/`, `state/`, `plans/`, `journal/`,
+ * `knowledge/`, `policies/`). All daemon code is updated in lockstep, but
+ * shipped agent assets (≥186 `curl` invocations across task-flows and
+ * SKILL.md files) still spell paths the old way until the PR-6 content
+ * sweep lands. Without a translation layer, every legacy `curl -X PATCH
+ * /api/context/today.md` would 404 the moment the new layout boots.
+ *
+ * **Why not HTTP 308.** The shipped `curl` invocations omit `-L`, so an
+ * HTTP 3xx would terminate the request rather than follow it. The
+ * resolver therefore performs the mapping **in-process before any HTTP
+ * routing**, and the route handler emits its normal `200/201/4xx` for
+ * the canonical path.
+ *
+ * **Where to call it.** Anywhere the daemon converts a vault-path
+ * string into a filesystem read/write — primarily the
+ * `/api/context/<path>` chokepoint in `api/routes/context/index.ts`,
+ * and the snapshot-restore + DB path-key migration in `setup-migrate.ts`.
+ * The single helper guarantees old and new spellings cannot drift.
+ *
+ * **Scope.** Only the path *string* is translated. PATCH section names,
+ * HTTP verbs, request bodies, and snapshot trigger labels are all left
+ * untouched — the legacy aliases are 1:1 with the new spellings, no
+ * shape changes ride along.
+ *
+ * **Lifecycle.** The alias is intended to live for **one minor release**
+ * (one `aitne` version) — long enough for the PR-6 agent-asset content
+ * sweep to rewrite every shipped reference. After that the aliases stay
+ * but emit an operator-visible warning, and the final removal lands in
+ * the subsequent minor release. The mechanism itself is idempotent and
+ * cheap; the lifetime cap is for prose-correctness, not safety.
+ */
+/**
+ * Sorted longest-prefix-first. Used by `aliasVaultPath` to translate
+ * legacy paths and by the migration's JSON-blob rewrite step
+ * (`rewriteJsonBlobs` in `db/migrations/context-vault-restructure.ts`)
+ * to rewrite vault paths embedded in `agent_actions.detail`,
+ * `observations.payload`, and `messages.metadata`.
+ */
+export const VAULT_PATH_ALIASES = [
+    // Directory-prefix renames. Longest first.
+    // `rules/policies/` (legacy capture dir) before `rules/`.
+    { fromPrefix: "rules/policies/", toPrefix: "policies/management-captures/" },
+    // `agent/scratch/` before `agent/`.
+    { fromPrefix: "agent/scratch/", toPrefix: "state/scratch/" },
+    // `agent/journal` (file, with or without `.md`).
+    { fromPrefix: "agent/journal", toPrefix: "journal/agent", exactOnly: true },
+    // `agent/profile-questions` (file, with or without `.md`).
+    {
+        fromPrefix: "agent/profile-questions",
+        toPrefix: "state/profile-questions",
+        exactOnly: true,
+    },
+    // Generic `rules/` and `routines/`.
+    { fromPrefix: "rules/", toPrefix: "policies/" },
+    { fromPrefix: "routines/", toPrefix: "policies/routines/" },
+    // `projects/` → `plans/projects/`.
+    { fromPrefix: "projects/", toPrefix: "plans/projects/" },
+    // Journal subtrees.
+    { fromPrefix: "daily/", toPrefix: "journal/daily/" },
+    { fromPrefix: "weekly/", toPrefix: "journal/weekly/" },
+    { fromPrefix: "monthly/", toPrefix: "journal/monthly/" },
+    // Knowledge subtrees.
+    { fromPrefix: "dossiers/", toPrefix: "knowledge/dossiers/" },
+    // State subtrees.
+    { fromPrefix: "inbox/", toPrefix: "state/inbox/" },
+    { fromPrefix: "_activity/", toPrefix: "state/activity/" },
+    // Identity (user/).
+    { fromPrefix: "user/", toPrefix: "identity/" },
+    // Loose top-level files. `exactOnly` so `today.md.bak` isn't aliased.
+    { fromPrefix: "today", toPrefix: "state/today", exactOnly: true },
+    { fromPrefix: "yesterday", toPrefix: "state/yesterday", exactOnly: true },
+    { fromPrefix: "roadmap", toPrefix: "plans/roadmap", exactOnly: true },
+];
+/**
+ * git/<slug>/overview.md → knowledge/repos/<slug>/overview.md
+ * git/<slug>/journal/<date>.md → journal/repos/<slug>/<date>.md
+ *
+ * These are pattern-aliases (not prefix-aliases) because the slug
+ * segment is part of the canonical destination. Handled separately so
+ * the prefix walker stays a pure prefix scan.
+ */
+const GIT_OVERVIEW_RE = /^git\/([^/]+)\/overview(\.md)?$/;
+const GIT_JOURNAL_RE = /^git\/([^/]+)\/journal\/([^/]+?)(\.md)?$/;
+/**
+ * Management entity / domain-index pattern aliases. Domains live in
+ * `packages/shared/src/management-domains.ts`; the regex matches any
+ * leading segment so the pattern doesn't need to enumerate them. The
+ * caller still gets a stable canonical form regardless.
+ *
+ * `<domain>/_index.md` → `knowledge/entities/<domain>/_index.md`
+ * `<domain>/<type-plural>/<slug>(.md)?` → `knowledge/entities/<domain>/<type-plural>/<slug>(.md)?`
+ *
+ * Recognised domains are pinned to avoid colliding with arbitrary
+ * top-level paths the user may have under the vault root. The list
+ * mirrors `MANAGEMENT_DOMAINS` in `packages/shared/src/management-domains.ts`.
+ */
+const MANAGEMENT_DOMAIN_NAMES = [
+    "work",
+    "travel",
+    "finance",
+    "personal",
+    "health",
+    "learning",
+];
+const DOMAIN_INDEX_RE = new RegExp(`^(?<domain>${MANAGEMENT_DOMAIN_NAMES.join("|")})/_index(\\.md)?$`);
+const DOMAIN_ENTITY_RE = new RegExp(`^(?<domain>${MANAGEMENT_DOMAIN_NAMES.join("|")})/(?<typePlural>[a-z][a-z0-9-]*)/(?<slug>[^/]+?)(\\.md)?$`);
+/**
+ * Translate a vault-relative path from its legacy spelling to its
+ * canonical six-class spelling. Returns the input verbatim (with
+ * `aliased=false`) if no rule applies.
+ *
+ * Idempotent: calling the resolver on an already-canonical path is a
+ * no-op. This is what makes it safe to invoke unconditionally at every
+ * entry point.
+ *
+ * The resolver does not validate that the resulting path is reachable
+ * on disk — that is the caller's job (e.g. `safePath` for the HTTP
+ * route). The job here is purely string translation.
+ */
+export function aliasVaultPath(relativePath) {
+    // Defensive normalisation — strip a leading slash so the resolver can
+    // be called with either form. Trailing slashes are preserved
+    // (callers like the migration manifest use `state/inbox/` as a dir).
+    const input = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
+    // Already canonical — fast path.
+    if (isCanonicalSixClassPath(input)) {
+        return { canonicalPath: input, legacyPath: input, aliased: false };
+    }
+    // Pattern aliases first (git fanout + management entities).
+    const gitOverview = GIT_OVERVIEW_RE.exec(input);
+    if (gitOverview) {
+        const slug = gitOverview[1];
+        const suffix = gitOverview[2] ?? "";
+        return {
+            canonicalPath: `knowledge/repos/${slug}/overview${suffix}`,
+            legacyPath: input,
+            aliased: true,
+        };
+    }
+    const gitJournal = GIT_JOURNAL_RE.exec(input);
+    if (gitJournal) {
+        const slug = gitJournal[1];
+        const date = gitJournal[2];
+        const suffix = gitJournal[3] ?? "";
+        return {
+            canonicalPath: `journal/repos/${slug}/${date}${suffix}`,
+            legacyPath: input,
+            aliased: true,
+        };
+    }
+    const domainIndex = DOMAIN_INDEX_RE.exec(input);
+    if (domainIndex) {
+        const { domain } = domainIndex.groups;
+        const suffix = input.endsWith(".md") ? ".md" : "";
+        return {
+            canonicalPath: `knowledge/entities/${domain}/_index${suffix}`,
+            legacyPath: input,
+            aliased: true,
+        };
+    }
+    const domainEntity = DOMAIN_ENTITY_RE.exec(input);
+    if (domainEntity) {
+        const { domain, typePlural, slug } = domainEntity.groups;
+        const suffix = input.endsWith(".md") ? ".md" : "";
+        return {
+            canonicalPath: `knowledge/entities/${domain}/${typePlural}/${slug}${suffix}`,
+            legacyPath: input,
+            aliased: true,
+        };
+    }
+    // Prefix aliases.
+    for (const alias of VAULT_PATH_ALIASES) {
+        if (alias.exactOnly) {
+            if (input === alias.fromPrefix) {
+                return {
+                    canonicalPath: alias.toPrefix,
+                    legacyPath: input,
+                    aliased: true,
+                };
+            }
+            if (input === `${alias.fromPrefix}.md`) {
+                return {
+                    canonicalPath: `${alias.toPrefix}.md`,
+                    legacyPath: input,
+                    aliased: true,
+                };
+            }
+            continue;
+        }
+        if (input.startsWith(alias.fromPrefix)) {
+            return {
+                canonicalPath: alias.toPrefix + input.slice(alias.fromPrefix.length),
+                legacyPath: input,
+                aliased: true,
+            };
+        }
+    }
+    return { canonicalPath: input, legacyPath: input, aliased: false };
+}
+/**
+ * The six top-level classes the new layout uses. A path that already
+ * starts with one of these is canonical and the resolver short-circuits.
+ */
+const CANONICAL_PREFIXES = [
+    "identity/",
+    "state/",
+    "plans/",
+    "journal/",
+    "knowledge/",
+    "policies/",
+];
+function isCanonicalSixClassPath(input) {
+    if (input === "_index.md" || input === "_index")
+        return true;
+    // `.context-vault-version` is a runtime marker that lives at the
+    // contextDir root; it's not a "vault content" path but consumers
+    // sometimes round-trip it.
+    if (input === ".context-vault-version")
+        return true;
+    for (const prefix of CANONICAL_PREFIXES) {
+        if (input.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+/**
+ * Diagnostic helper — returns every alias entry whose `fromPrefix` would
+ * shadow another. Used by a peer test to assert the static table stays
+ * in longest-prefix-first order. The `aliases` parameter defaults to the
+ * production table; tests pass a deliberately mis-ordered list to exercise
+ * the shadow-detection branch.
+ */
+export function findShadowingAliases(aliases = VAULT_PATH_ALIASES) {
+    const shadows = [];
+    for (let i = 0; i < aliases.length; i++) {
+        const earlier = aliases[i];
+        for (let j = i + 1; j < aliases.length; j++) {
+            const later = aliases[j];
+            if (earlier.exactOnly || later.exactOnly)
+                continue;
+            if (later.fromPrefix.startsWith(earlier.fromPrefix)) {
+                shadows.push({ earlier, shadowed: later });
+            }
+        }
+    }
+    return shadows;
+}

package/dist/core/custom-routine-scheduler.d.ts

@@ -3,7 +3,7 @@ import { customRoutineSlugFromKey } from "@aitne/shared";
 import type { EventBus } from "./event-bus.js";
 /**
  * B-007 §5.8 Q3 — user-defined routines registered under
- * `context/routines/custom/<slug>.md`. Each file's YAML frontmatter
+ * `context/policies/routines/custom/<slug>.md`. Each file's YAML frontmatter
  * describes the cadence and the runtime budget; `CustomRoutineScheduler`
  * enumerates them at startup, wires a `node-cron` job per enabled
  * routine, and pushes a `routine.custom.<slug>` event into the EventBus
@@ -17,7 +17,7 @@ import type { EventBus } from "./event-bus.js";
  *   running → stop() → stopped (all cron jobs cleared)
  *
  * No fs.watch is used. The context API route (`src/api/routes/context.ts`)
- * calls `reload()` after every PUT/PATCH/DELETE under `routines/custom/`.
+ * calls `reload()` after every PUT/PATCH/DELETE under `policies/routines/custom/`.
  */
 export interface CustomRoutineSpec {
     slug: string;
@@ -69,7 +69,7 @@ export interface CustomRoutineEnumerationResult {
     }[];
 }
 /**
- * Parse a `routines/custom/<slug>.md` file body into a validated spec.
+ * Parse a `policies/routines/custom/<slug>.md` file body into a validated spec.
  * Pure function — safe to unit-test exhaustively. Returns a discriminated
  * result so callers can log structured errors without throwing.
  */
@@ -81,7 +81,7 @@ export declare function parseCustomRoutineSpec(slug: string, body: string): {
     error: CustomRoutineParseError;
 };
 /**
- * Enumerate every `routines/custom/*.md` file under `contextDir` and
+ * Enumerate every `policies/routines/custom/*.md` file under `contextDir` and
  * parse each into a spec. Errors are returned alongside the successful
  * specs so the scheduler can log them without aborting startup.
  *
@@ -142,10 +142,9 @@ export declare class CustomRoutineScheduler {
     private fire;
 }
 /**
- * Convenience: extract the slug from a `routines/custom/<slug>.md` path.
+ * Convenience: extract the slug from a `policies/routines/custom/<slug>.md` path.
  * Returns null if the path is outside the custom-routine directory.
  * Used by the context API route when deciding whether to call `reload()`.
  */
 export declare function slugFromCustomRoutinePath(relativePath: string): string | null;
 export { customRoutineSlugFromKey };
-//# sourceMappingURL=custom-routine-scheduler.d.ts.map

package/dist/core/custom-routine-scheduler.js

@@ -36,7 +36,7 @@ function hasChecksSection(content) {
     return /^##\s+Checks\s*$/m.test(content);
 }
 /**
- * Parse a `routines/custom/<slug>.md` file body into a validated spec.
+ * Parse a `policies/routines/custom/<slug>.md` file body into a validated spec.
  * Pure function — safe to unit-test exhaustively. Returns a discriminated
  * result so callers can log structured errors without throwing.
  */
@@ -127,7 +127,7 @@ export function parseCustomRoutineSpec(slug, body) {
     };
 }
 /**
- * Enumerate every `routines/custom/*.md` file under `contextDir` and
+ * Enumerate every `policies/routines/custom/*.md` file under `contextDir` and
  * parse each into a spec. Errors are returned alongside the successful
  * specs so the scheduler can log them without aborting startup.
  *
@@ -315,7 +315,7 @@ export class CustomRoutineScheduler {
     }
 }
 /**
- * Convenience: extract the slug from a `routines/custom/<slug>.md` path.
+ * Convenience: extract the slug from a `policies/routines/custom/<slug>.md` path.
  * Returns null if the path is outside the custom-routine directory.
  * Used by the context API route when deciding whether to call `reload()`.
  */
@@ -332,4 +332,3 @@ export function slugFromCustomRoutinePath(relativePath) {
     return slug;
 }
 export { customRoutineSlugFromKey };
-//# sourceMappingURL=custom-routine-scheduler.js.map

package/dist/core/daemon-api-cli.d.ts

@@ -31,4 +31,3 @@ export interface DaemonApiCliEnvOptions {
     eventCorrelationId?: string;
 }
 export declare function buildDaemonApiCliEnv(sessionDir: string, apiPort: number, optionsOrReadToken?: string | DaemonApiCliEnvOptions): Record<string, string>;
-//# sourceMappingURL=daemon-api-cli.d.ts.map

package/dist/core/daemon-api-cli.js

@@ -40,6 +40,11 @@ const EVENT_CORRELATION_ID_ENV = "${DAEMON_API_EVENT_CORRELATION_ID_ENV}";
 const ALLOWED_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
 const ALLOWED_HEADERS = new Set([
   "content-type",
+  // The shim sets a sensible default Accept itself; honour an explicit one
+  // too so a request-format hint the agent adds out of habit
+  // (\`-H "Accept: application/json"\`) does not fail the whole call and
+  // burn a retry turn.
+  "accept",
   "x-lock-id",
   "x-session-id",
   // DELEGATED-MODE-V2-DESIGN.md §4.2.3 — delegated-mode pathway. The
@@ -316,6 +321,9 @@ const SESSION_ID_ENV = "${DAEMON_API_SESSION_ID_ENV}";
 const EVENT_CORRELATION_ID_ENV = "${DAEMON_API_EVENT_CORRELATION_ID_ENV}";
 const ALLOWED_HEADERS = new Set([
   "content-type",
+  // Honour an explicit Accept (the shim also sets a default) so the agent's
+  // habitual \`-H "Accept: application/json"\` does not fail and trigger a retry.
+  "accept",
   "x-lock-id",
   "x-session-id",
   "x-turn-token",
@@ -496,6 +504,38 @@ async function main() {
       idx += 1;
       continue;
     }
+    // Real curl 7.82+ \`--json <body>\` is shorthand for setting
+    // Content-Type: application/json + Accept: application/json + sending
+    // the body. The agent learns this shape from skill prose and from
+    // pa-api (which has its own --json). Matching curl's behavior here
+    // avoids the previous "Unsupported curl flag: --json" failure that
+    // burned budget on every routine.morning_routine_today retry.
+    if (arg === "--json") {
+      const rawBody = args[idx + 1];
+      if (rawBody === undefined) {
+        fail("--json requires a value.");
+      }
+      if (rawBody === "@-") {
+        body = await readAllStdin();
+      } else if (rawBody.length > 0 && rawBody[0] === "@") {
+        fail(\`--json \${rawBody}: @<path> file-read syntax is not allowed; use \\\`--json @-\\\` with a heredoc instead.\`);
+      } else {
+        body = rawBody;
+      }
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+      }
+      headers.set("accept", "application/json");
+      idx += 1;
+      continue;
+    }
+    // Real curl \`-I\` / \`--head\` issues a HEAD request. HEAD is in
+    // ALLOWED_METHODS so this is safe; supporting the flag keeps the
+    // agent's muscle memory working when it probes for existence.
+    if (arg === "-I" || arg === "--head") {
+      method = "HEAD";
+      continue;
+    }
     if (arg === "-o" || arg === "--output") {
       const filePath = args[idx + 1];
       if (!filePath) {
@@ -647,6 +687,25 @@ export function ensureDaemonApiCli(sessionDir) {
     chmodSync(cliPath, 0o700);
     writeFileSync(curlShimPath, DAEMON_CURL_SHIM_SOURCE, { encoding: "utf-8", mode: 0o700 });
     chmodSync(curlShimPath, 0o700);
+    // POSIX: the shebang + 0o700 makes the extensionless scripts executable and
+    // PATH-resolvable. On Windows, CreateProcess/cmd only run files whose ext is
+    // in PATHEXT, so an extensionless shebang file is never executed: a bare
+    // `curl` would silently fall through to the real curl.exe (bypassing the
+    // daemon-API auth/header injection and safety hooks) and `pa-api` would be
+    // "command not found". Write sibling .cmd launchers so PATHEXT resolution
+    // finds these and shadows the real curl.exe; cmd propagates node's errorlevel
+    // as the exit code. (The chmod above is a harmless near-no-op on Windows.)
+    /* c8 ignore start -- win32-only PATHEXT shim; the POSIX test runner never enters this branch */
+    if (process.platform === "win32") {
+        const binDir = join(sessionDir, SESSION_DAEMON_API_BIN_DIR);
+        writeFileSync(join(binDir, "pa-api.cmd"), '@echo off\r\nnode "%~dp0pa-api" %*\r\n', {
+            encoding: "utf-8",
+        });
+        writeFileSync(join(binDir, "curl.cmd"), '@echo off\r\nnode "%~dp0curl" %*\r\n', {
+            encoding: "utf-8",
+        });
+    }
+    /* c8 ignore stop */
     return cliPath;
 }
 export function buildDaemonApiCliEnv(sessionDir, apiPort, optionsOrReadToken) {
@@ -658,7 +717,7 @@ export function buildDaemonApiCliEnv(sessionDir, apiPort, optionsOrReadToken) {
         pathParts.push(process.env.PATH);
     }
     const env = {
-        ...Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string")),
+        ...Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string" && entry[0].toUpperCase() !== "PATH")),
         PATH: pathParts.join(delimiter),
         [DAEMON_API_BASE_URL_ENV]: `http://127.0.0.1:${apiPort}`,
     };
@@ -700,4 +759,3 @@ export function buildDaemonApiCliEnv(sessionDir, apiPort, optionsOrReadToken) {
     }
     return env;
 }
-//# sourceMappingURL=daemon-api-cli.js.map

package/dist/core/dashboard-session-cleanup.d.ts

@@ -36,4 +36,3 @@ export declare function deleteChatSession(params: {
     dataDir: string;
     sessionId: number;
 }): DeleteSessionResult;
-//# sourceMappingURL=dashboard-session-cleanup.d.ts.map

package/dist/core/dashboard-session-cleanup.js

@@ -105,4 +105,3 @@ export function deleteChatSession(params) {
     logger.info({ sessionId: row.id, scope: row.scope }, "Dashboard deleted chat sidebar session");
     return { ok: true, deleted };
 }
-//# sourceMappingURL=dashboard-session-cleanup.js.map

package/dist/core/dashboard-session-controls.d.ts

@@ -38,4 +38,3 @@ export declare function continueDashboardSession(params: {
     sessionManager: ISessionManager;
     sessionId: number;
 }): DashboardContinueResult;
-//# sourceMappingURL=dashboard-session-controls.d.ts.map

package/dist/core/dashboard-session-controls.js

@@ -151,4 +151,3 @@ export function continueDashboardSession(params) {
     params.sessionManager.flushEffects(effects);
     return { ok: true, sessionId: sessionRow.id };
 }
-//# sourceMappingURL=dashboard-session-controls.js.map

package/dist/core/delegated-connector-health.d.ts

@@ -60,4 +60,3 @@ export declare function markSignoutWarned(db: Database.Database, warning: Delega
  * into `INotificationManager.send`. US-English per Decision Log #11.
  */
 export declare function renderSignoutDm(warning: DelegatedSignoutWarning): string;
-//# sourceMappingURL=delegated-connector-health.d.ts.map

package/dist/core/delegated-connector-health.js

@@ -154,4 +154,3 @@ export function renderSignoutDm(warning) {
         `Re-authorize from your ${warning.backend} connector settings, then re-run the integration probe from the dashboard.`,
     ].join(" ");
 }
-//# sourceMappingURL=delegated-connector-health.js.map

package/dist/core/dispatcher-date-utils.d.ts

@@ -46,4 +46,3 @@ export declare function getLocalDateParts(date: Date, timeZone?: string): LocalD
  * passed today.
  */
 export declare function compareLocalDateParts(a: LocalDateParts, b: LocalDateParts): number;
-//# sourceMappingURL=dispatcher-date-utils.d.ts.map

package/dist/core/dispatcher-date-utils.js

@@ -129,4 +129,3 @@ export function compareLocalDateParts(a, b) {
         return a.hour - b.hour;
     return a.minute - b.minute;
 }
-//# sourceMappingURL=dispatcher-date-utils.js.map

package/dist/core/dispatcher-error-handling.d.ts

@@ -169,4 +169,3 @@ export declare class DispatcherErrorRouter {
      */
     runDelegatedConnectorWarningDispatch(warnings: readonly DelegatedSignoutWarning[], event: MessageEvent, sessionBackend: BackendId, sessionId: number): void;
 }
-//# sourceMappingURL=dispatcher-error-handling.d.ts.map

package/dist/core/dispatcher-error-handling.js

@@ -459,4 +459,3 @@ export class DispatcherErrorRouter {
         }
     }
 }
-//# sourceMappingURL=dispatcher-error-handling.js.map

package/dist/core/dispatcher-hourly-check.d.ts

@@ -219,4 +219,3 @@ export declare class HourlyCheckCoordinator {
      */
     private runStage2Triage;
 }
-//# sourceMappingURL=dispatcher-hourly-check.d.ts.map

package/dist/core/dispatcher-hourly-check.js

@@ -512,11 +512,19 @@ export class HourlyCheckCoordinator {
                 ? `[hourly_check] Quiet (${decision.reason}) — ${pendingCount} obs consumed silently`
                 : `[hourly_check] Stage 2 log-only (${decision.reason}) — ${pendingCount} obs consumed silently`;
             if (this.todayWriteLock) {
-                appendAgentLogLine({
+                // Fire-and-forget: the silent-path return is a sync object the
+                // gate caller needs immediately to bookkeep observations. The
+                // Agent Log bullet is a best-effort trace (skipping is already
+                // an accepted outcome per AppendAgentLogLineResult.reason), so
+                // we don't await it. The serializer inside ensures the write
+                // does not race with HTTP context PATCHes on today.md.
+                void appendAgentLogLine({
                     contextDir: getContextDir(this.config, this.db),
                     message,
                     todayWriteLock: this.todayWriteLock,
                     timezone: this.config.timezone || undefined,
+                }).catch((err) => {
+                    logger.error({ err }, "Daemon-direct Agent Log append threw — silent-path observations were still consumed");
                 });
             }
             // Consume the observations under the gate's correlation id so
@@ -760,4 +768,3 @@ export class HourlyCheckCoordinator {
         return parseStage2Verdict(result.output);
     }
 }
-//# sourceMappingURL=dispatcher-hourly-check.js.map

package/dist/core/dispatcher-message-handler.d.ts

@@ -91,6 +91,25 @@ export interface MessageHandlerDeps {
     getAuthHealthMonitor: () => import("./backends/auth-health-monitor.js").AuthHealthMonitor | null;
     /** Lazily-injected bang-command registry accessor. */
     getBangCommandRegistry: () => import("./bang-commands/registry.js").BangCommandRegistry | null;
+    /** Lazily-injected B-4 purchase-handler accessor. Null in tests and
+     *  before B-4 is wired at startup. Used by the inbound classifier at
+     *  the top of `handle()` to short-circuit `!~xxxxxxxx`,
+     *  `!verify <tail>`, and `!cancel-purchase` inputs BEFORE the LLM
+     *  (or the bang-command registry) sees them — see
+     *  MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.4 / §17.7. */
+    getPurchaseHandler?: () => import("../services/browser-history/automation/purchase-handler.js").PurchaseHandler | null;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11 (Q#6 MVP blocker) — lazily-
+     * injected lite-final-confirm handler accessor. Null in tests and
+     * before the browser-task surface is wired at startup. Used by the
+     * inbound `!~xxxxxxxx` classifier alongside `getPurchaseHandler`: the
+     * adapter routes a reply by querying BOTH stores via `lookupByRaw`
+     * and dispatching to whichever returned a row. The strict-cancel-on-
+     * non-token-reply contract is replicated symmetrically across both
+     * surfaces so a single non-token reply cancels pending tokens of
+     * either kind on the affected channel.
+     */
+    getFinalConfirmHandler?: () => import("../services/browser-history/automation/final-confirm-handler.js").FinalConfirmHandler | null;
     /** Live getter for the dispatcher's `currentSetupMode` flag. */
     getCurrentSetupMode: () => SetupMode | null;
     /** Forward into the dispatcher's `beginSetupMode` so persistence stays
@@ -126,6 +145,8 @@ export declare class MessageHandler {
     private readonly getAuthRecovery;
     private readonly getAuthHealthMonitor;
     private readonly getBangCommandRegistry;
+    private readonly getPurchaseHandler;
+    private readonly getFinalConfirmHandler;
     private readonly getCurrentSetupMode;
     private readonly beginSetupMode;
     private readonly lookupCustomBangCommandForEvent;
@@ -177,4 +198,3 @@ export declare class MessageHandler {
         triggerMatched: boolean;
     };
 }
-//# sourceMappingURL=dispatcher-message-handler.d.ts.map