@aitne/daemon 0.1.8 → 0.1.9

package/dist/core/morning/agent-journal-appender.js

@@ -1,6 +1,6 @@
 /**
  * `appendMorningRoutineJournalEntry` — assemble the one-block English
- * audit-trail entry for `agent/journal.md` from **structured sources
+ * audit-trail entry for `journal/agent.md` from **structured sources
  * only** (agent_actions rows + daily/<yesterday>.md frontmatter
  * deterministic fs read) and append it to the journal file.
  *
@@ -19,9 +19,18 @@
  *     - Checks from routines/morning.md: (none)
  *     - Anomalies / skipped steps: (none)
  *
- * Initial-flow / Stage-B-failed branches surface the rev1 variant:
+ * The `- Journal: ...` line is replaced by a `Journal synthesis: ...`
+ * variant when the daily file is absent or Stage B did not succeed:
  *
- *     - Journal synthesis: skipped (no prior-day data)
+ *     - Journal synthesis: skipped (no prior-day data)               (first-run)
+ *     - Journal synthesis: failed (audit row missing — see daemon log) (anomaly)
+ *     - Journal synthesis: failed (Stage B <state>)                   (terminal failure)
+ *     - Journal synthesis: failed (Stage B success but daily file missing) (PUT lost)
+ *
+ * The verb (`skipped` vs `failed`) reflects whether Stage B was even
+ * attempted — `skipped` is reserved for the first-run case where the
+ * orchestrator never dispatched Stage B; everything else surfaces as
+ * `failed` so the audit-trail language matches reality.
  *
  * No LLM final-text parsing anywhere — every field is sourced from a
  * structured channel: `agent_actions.metadata` (written by Stage A via
@@ -31,6 +40,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileAtomically } from "../atomic-write.js";
+import { serializeContextFileWrite } from "../context-file-serializer.js";
 import { CONTEXT_RELATIVE_PATHS, dailyJournalPath } from "../context-paths.js";
 import { createLogger } from "../../logging.js";
 import { gatherJournalSkeletonFacts, } from "./journal-skeleton-builder.js";
@@ -67,7 +77,8 @@ export function loadMorningRoutineActionRows(db, correlationId) {
     const rows = db
         .prepare(`SELECT action_type AS actionType,
               result AS result,
-              metadata AS metadata
+              metadata AS metadata,
+              detail AS detail
          FROM agent_actions
         WHERE event_id = ?
           AND action_type IN (?, ?)
@@ -76,9 +87,13 @@ export function loadMorningRoutineActionRows(db, correlationId) {
     let stageA = null;
     let stageB = null;
     for (const row of rows) {
+        const dailyWrite = row.actionType === STAGE_B_ACTION_TYPE
+            ? parseDailyWriteDetail(row.detail)
+            : null;
         const parsed = {
             result: row.result,
             metadata: parseJsonObject(row.metadata),
+            ...(dailyWrite ? { dailyWrite } : {}),
         };
         if (row.actionType === STAGE_A_ACTION_TYPE) {
             // Most recent insert wins on a retry — `ORDER BY id ASC` + naive
@@ -92,6 +107,74 @@ export function loadMorningRoutineActionRows(db, correlationId) {
     }
     return { stageA, stageB };
 }
+/**
+ * Pull `dailyWrite` out of an `agent_actions.detail` JSON column.
+ * Returns null when the column is null, malformed, or carries an
+ * unrecognised shape. Strict validation: every required field must be
+ * present with the right type — a partial-shape row degrades to
+ * "field absent" so the appender falls back to file-presence
+ * detection rather than rendering a half-broken line.
+ */
+function parseDailyWriteDetail(raw) {
+    if (raw === null)
+        return null;
+    let parsed;
+    // SQLite's `detail` column has a CHECK(json_valid) constraint, so a
+    // malformed JSON string cannot reach this branch via the INSERT
+    // path. The try/catch is kept as a defence-in-depth guard for a
+    // future migration that relaxes the constraint.
+    /* c8 ignore start */
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    /* c8 ignore stop */
+    if (parsed === null || typeof parsed !== "object")
+        return null;
+    const dw = parsed.dailyWrite;
+    if (dw === null || typeof dw !== "object")
+        return null;
+    const obj = dw;
+    const ok = obj.ok;
+    if (ok === "complete") {
+        return {
+            ok: "complete",
+            ...(typeof obj.bytesWritten === "number" ? { bytesWritten: obj.bytesWritten } : {}),
+            ...(obj.wroteMode === "put" || obj.wroteMode === "append_revision"
+                ? { wroteMode: obj.wroteMode }
+                : {}),
+        };
+    }
+    if (ok === "partial") {
+        const partialReason = obj.partialReason;
+        if (partialReason !== "frontmatter_tag_missing"
+            && partialReason !== "frontmatter_invalid_json"
+            && partialReason !== "frontmatter_schema_invalid") {
+            return null;
+        }
+        return {
+            ok: "partial",
+            partialReason,
+            ...(typeof obj.bytesWritten === "number" ? { bytesWritten: obj.bytesWritten } : {}),
+            ...(obj.wroteMode === "put" || obj.wroteMode === "append_revision"
+                ? { wroteMode: obj.wroteMode }
+                : {}),
+        };
+    }
+    if (ok === false) {
+        const reason = obj.reason;
+        if (reason !== "stage_b_null"
+            && reason !== "empty_output"
+            && reason !== "body_tag_missing"
+            && reason !== "write_failed") {
+            return null;
+        }
+        return { ok: false, reason };
+    }
+    return null;
+}
 const EMPTY_ACTIONS_SUMMARY = {
     totalActions: 0,
     actionsByType: [],
@@ -107,7 +190,7 @@ export function composeMorningRoutineJournalEntry(inputs) {
     const inbox = readInboxStats(metadata);
     const checks = readMorningChecks(metadata);
     const anomalies = readAnomalies(metadata);
-    const journalLine = formatJournalLine(inputs.yesterdayDateStr, inputs.stageB, inputs.dailyJournalContent);
+    const journalLine = formatJournalLine(inputs.yesterdayDateStr, inputs.stageB, inputs.dailyJournalContent, inputs.stageBAttempted ?? false);
     const lines = [];
     lines.push(`## ${inputs.morningDateStr} morning routine`);
     lines.push(`- Day-type: ${dayType}`);
@@ -142,20 +225,30 @@ function formatActionsLine(summary) {
     return `${summary.totalActions} total (${breakdown}${suffix})`;
 }
 /**
- * Append the composed entry to `agent/journal.md`. Mirrors the write
- * chokepoint that `PATCH /api/context/agent/journal?mode=append_to_file`
+ * Append the composed entry to `journal/agent.md`. Mirrors the write
+ * chokepoint that `PATCH /api/context/journal/agent?mode=append_to_file`
  * exposes to the agent: snapshot the existing file into
  * `md_file_snapshots`, write the new content atomically, then notify
  * the write tracker + indexer so observers don't tag the write as a
  * user-actor change.
  */
-export function appendMorningRoutineJournalEntry(deps, args) {
+export async function appendMorningRoutineJournalEntry(deps, args) {
     const { stageA, stageB } = loadMorningRoutineActionRows(deps.db, args.correlationId);
     if (stageA === null) {
         return { ok: false, reason: "stage_a_row_missing" };
     }
     const dailyPath = join(deps.contextDir, dailyJournalPath(args.yesterdayDateStr));
     const dailyContent = existsSync(dailyPath) ? readFileSync(dailyPath, "utf-8") : null;
+    // `stageBAttempted` discriminates "first-run / no prior-day" from
+    // "Stage B was attempted but no audit row exists" — the latter is a
+    // defence-in-depth anomaly that the previous renderer masked as a
+    // legit skip. The orchestrator's `buildStageBInputs` gates Stage B
+    // dispatch on `existsSync(yesterday.md)`; mirroring that check here
+    // (after `rotateDayFiles` has run and before the next day's rotation
+    // touches the file) gives us the same predicate without threading
+    // new state through the orchestrator → runner → appender chain.
+    const yesterdayMdPath = join(deps.contextDir, "state", "yesterday.md");
+    const stageBAttempted = existsSync(yesterdayMdPath);
     // Reuse the skeleton builder's aggregation for the agent-action
     // breakdown. The query is cheap (two indexed reads against
     // `agent_actions`) and re-running it here keeps the appender
@@ -174,26 +267,37 @@ export function appendMorningRoutineJournalEntry(deps, args) {
         stageB,
         dailyJournalContent: dailyContent,
         actionsSummary,
+        stageBAttempted,
     });
     const journalRelative = CONTEXT_RELATIVE_PATHS.agent.journal;
     const journalAbs = join(deps.contextDir, journalRelative);
-    const original = existsSync(journalAbs) ? readFileSync(journalAbs, "utf-8") : null;
-    const next = appendBlockToJournal(original, entryText);
-    if (original !== null) {
-        saveSnapshot(deps.db, journalRelative.replace(/\.md$/, ""), original, "morning_routine_appender");
-    }
-    // Mark before the rename so FS-watch consumers attribute the resulting
-    // event to the agent. Roll back on failure (C2).
-    deps.writeTracker?.markWriting(journalAbs, next);
-    try {
-        writeFileAtomically(journalAbs, next);
-    }
-    catch (writeErr) {
-        deps.writeTracker?.unmark(journalAbs);
-        throw writeErr;
-    }
-    deps.onIndexableContextChange?.(journalRelative);
-    return { ok: true, entryText };
+    // Read AND write inside the daemon-wide per-path serializer so a
+    // concurrent HTTP PATCH (`/api/context/journal/agent` append_to_file),
+    // a roadmap-maintenance journal-line append, or the weekly-interests
+    // appender cannot race this read-modify-write. Without the fence,
+    // two writers reading the same pre-state would each rename their
+    // own "next" over the file, silently dropping the loser's block.
+    return await serializeContextFileWrite(journalAbs, () => {
+        const original = existsSync(journalAbs)
+            ? readFileSync(journalAbs, "utf-8")
+            : null;
+        const next = appendBlockToJournal(original, entryText);
+        if (original !== null) {
+            saveSnapshot(deps.db, journalRelative.replace(/\.md$/, ""), original, "morning_routine_appender");
+        }
+        // Mark before the rename so FS-watch consumers attribute the resulting
+        // event to the agent. Roll back on failure (C2).
+        deps.writeTracker?.markWriting(journalAbs, next);
+        try {
+            writeFileAtomically(journalAbs, next);
+        }
+        catch (writeErr) {
+            deps.writeTracker?.unmark(journalAbs);
+            throw writeErr;
+        }
+        deps.onIndexableContextChange?.(journalRelative);
+        return { ok: true, entryText };
+    });
 }
 /**
  * Append a new top-level block (delimited by H2 heading) to the
@@ -322,10 +426,51 @@ function readStringArray(value) {
     }
     return out;
 }
-function formatJournalLine(yesterdayDateStr, stageB, dailyContent) {
+function formatJournalLine(yesterdayDateStr, stageB, dailyContent, stageBAttempted) {
+    // daily-journal-daemon-write.md §4.7 — preferred signal is the
+    // structured `detail.dailyWrite.ok` discriminant the §4.11 wiring
+    // lands on the Stage B row. When present, branch by `ok` and skip the
+    // file-presence heuristic entirely. The `dailyContent` branch below
+    // remains the fallback for (a) rows written before §4.11 (no
+    // dailyWrite key) and (b) future migrations where the composer is
+    // bypassed but the file is still on disk.
+    const dailyWrite = stageB?.dailyWrite;
+    if (dailyWrite) {
+        if (dailyWrite.ok === "complete") {
+            if (dailyContent !== null) {
+                const stats = inspectDailyJournal(dailyContent);
+                return `Journal: daily/${yesterdayDateStr}.md (${stats.bodyLineCount} lines, ${stats.projectsCount} projects referenced)`;
+            }
+            // Composer reported complete but file is no longer on disk —
+            // tail-risk shape (manual delete / vault move between settle and
+            // appender). Surface explicitly so a missing file isn't masked as
+            // a benign first-run.
+            return "Journal synthesis: failed (composer reported complete but daily file is missing)";
+        }
+        if (dailyWrite.ok === "partial") {
+            if (dailyContent !== null) {
+                const stats = inspectDailyJournal(dailyContent);
+                const reasonLabel = formatPartialReason(dailyWrite.partialReason);
+                return `Journal: daily/${yesterdayDateStr}.md (${stats.bodyLineCount} lines, **partial — ${reasonLabel}**)`;
+            }
+            // Partial extract means the body landed; missing file is the
+            // same tail-risk shape as above. Surface loudly.
+            return "Journal synthesis: failed (composer reported partial but daily file is missing)";
+        }
+        // ok === false — composer terminated without writing. Map the
+        // reason to a human-readable suffix so `pnpm audit` filters on it.
+        return `Journal synthesis: failed (${formatFailureReason(dailyWrite.reason)})`;
+    }
+    // Legacy fallback — rows that pre-date §4.11 have no dailyWrite key.
+    // Use file-presence + Stage B result to render the right verb.
     if (dailyContent !== null) {
         if (stageB !== null && stageB.result !== "success") {
-            return `Journal synthesis: skipped (Stage B ${stageB.result})`;
+            // Mismatch — daily file is on disk (likely from a prior-attempt
+            // PUT) but the latest Stage B row is non-success. Surfaces as
+            // `failed` so the verb matches reality (`skipped` would imply the
+            // stage didn't run, which is wrong); the parenthetical preserves
+            // the terminal state for operators triaging via `pnpm audit`.
+            return `Journal synthesis: failed (Stage B ${stageB.result})`;
         }
         const stats = inspectDailyJournal(dailyContent);
         return `Journal: daily/${yesterdayDateStr}.md (${stats.bodyLineCount} lines, ${stats.projectsCount} projects referenced)`;
@@ -334,25 +479,33 @@ function formatJournalLine(yesterdayDateStr, stageB, dailyContent) {
     //
     // Disambiguate the missing-file branch by Stage B state so the audit
     // trail surfaces real anomalies instead of masking them as "no prior
-    // day". Three sub-cases:
-    //   1. Stage B was skipped (`stageB === null`) — first-run initial
-    //      variant. Rendering "no prior-day data" is correct.
-    //   2. Stage B ran and failed (`result !== 'success'`) — render the
-    //      terminal state. Matches the dailyContent-present-but-failed
-    //      branch above so the audit log uses one consistent shape per
-    //      Stage B outcome.
-    //   3. Stage B ran and succeeded but the file is not on disk — a real
+    // day". Four sub-cases:
+    //   1. Stage B was not attempted (`!stageBAttempted` — i.e. yesterday.md
+    //      was absent at run start) — first-run / no-prior-day. Rendering
+    //      "skipped (no prior-day data)" is correct.
+    //   2. Stage B was attempted but produced no audit row (the
+    //      defence-in-depth anomaly the `stageBAttempted` discriminator
+    //      surfaces — see `JournalEntryComposeInputs.stageBAttempted`.
+    //      Renders as "failed (audit row missing — see daemon log)" so
+    //      the failure is loud rather than masked as first-run.
+    //   3. Stage B ran and failed (`result !== 'success'`) — render the
+    //      terminal state with the `failed` verb so the audit-trail line
+    //      matches reality.
+    //   4. Stage B ran and succeeded but the file is not on disk — a real
     //      anomaly (atomic PUT lost, fs race, or the appender ran before
     //      the PUT settled). Surface explicitly so `pnpm audit` can
     //      filter on it; the original "no prior-day data" string silently
     //      masked this as a benign first-run condition.
     if (stageB === null) {
+        if (stageBAttempted) {
+            return "Journal synthesis: failed (audit row missing — see daemon log)";
+        }
         return "Journal synthesis: skipped (no prior-day data)";
     }
     if (stageB.result !== "success") {
-        return `Journal synthesis: skipped (Stage B ${stageB.result})`;
+        return `Journal synthesis: failed (Stage B ${stageB.result})`;
     }
-    return "Journal synthesis: skipped (Stage B success but daily file missing)";
+    return "Journal synthesis: failed (Stage B success but daily file missing)";
 }
 /**
  * Pull body-line count + projects-array length from a `daily/<date>.md`
@@ -432,6 +585,28 @@ function countProjectsField(content) {
     }
     return 0;
 }
+function formatPartialReason(reason) {
+    switch (reason) {
+        case "frontmatter_tag_missing":
+            return "frontmatter tag missing";
+        case "frontmatter_invalid_json":
+            return "frontmatter JSON parse error";
+        case "frontmatter_schema_invalid":
+            return "frontmatter schema mismatch";
+    }
+}
+function formatFailureReason(reason) {
+    switch (reason) {
+        case "stage_b_null":
+            return "Stage B did not run";
+        case "empty_output":
+            return "LLM output empty";
+        case "body_tag_missing":
+            return "extraction: no body";
+        case "write_failed":
+            return "write error";
+    }
+}
 function parseJsonObject(raw) {
     if (raw === null)
         return {};
@@ -455,4 +630,3 @@ function saveSnapshot(db, filePath, content, trigger) {
         logger.warn({ err, filePath, trigger }, "Failed to save md_file_snapshots row");
     }
 }
-//# sourceMappingURL=agent-journal-appender.js.map

package/dist/core/morning/daily-journal-composer.d.ts

@@ -0,0 +1,183 @@
+/**
+ * `DailyJournalComposer` — Stage B reliability fix per
+ * `docs/design/appendices/daily-journal-daemon-write.md` rev1.
+ *
+ * Before this module, Stage B (`routine.morning_routine_journal`, Haiku
+ * 4.5 lite tier) was specified to author yesterday's daily journal AND
+ * PUT it to `/api/context/daily/<yesterday>.md`. Haiku failed at the
+ * curl PUT step 4 out of 5 recent runs (`cat > /tmp/...` denials it
+ * didn't recover from). The fix decouples creative authoring (LLM) from
+ * mechanical I/O (daemon):
+ *
+ *   - Stage B emits its body + frontmatter facts as two XML-tagged
+ *     blocks (`<aitne:daily-journal-body>` /
+ *     `<aitne:daily-journal-frontmatter>`) in its final assistant text
+ *     — no tool calls.
+ *   - This module extracts both blocks, composes the final
+ *     `daily/<date>.md` content with skeleton-owned frontmatter, and
+ *     writes it through `performContextFileWrite` — same atomic +
+ *     snapshot + writeTracker invariants the HTTP route uses.
+ *
+ * Three-state result discriminant (`ok: "complete" | "partial" | false`)
+ * surfaces partial extracts as a first-class outcome rather than
+ * folding them into success: when the body extracts but frontmatter
+ * does not, the diary content lands on disk but the wiki link graph
+ * for that day is degraded, and the appender bolds "partial — …" so
+ * weekly review can spot the regression.
+ *
+ * Tag boundary rules — kept intentionally strict, see design §4.4.
+ * LAST-wins selection + `aitne:` namespace prefix make body
+ * collisions (the user quotes the literal token while documenting
+ * Aitne itself) safe.
+ */
+import type Database from "better-sqlite3";
+import { z } from "zod";
+import type { AgentWriteTracker } from "../../safety/agent-write-tracker.js";
+import type { AgentResult } from "@aitne/shared";
+import type { JournalSkeletonInputs } from "./journal-skeleton-builder.js";
+/**
+ * Zod schema for the LLM-supplied frontmatter block. Three optional
+ * string arrays (projects / people / tags) — anything else the LLM
+ * provides is silently dropped (Zod's default strip) per design §4.6.
+ *
+ * `.default([])` lets the LLM omit a field entirely; absent → empty
+ * array. An empty array is a legitimate value (the user mentioned no
+ * people that day). Empty strings inside the array are dropped at
+ * compose time before YAML serialisation.
+ */
+export declare const JournalFrontmatterSchema: z.ZodObject<{
+    projects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    people: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type JournalFrontmatter = z.infer<typeof JournalFrontmatterSchema>;
+/** Recoverable — the body was extracted and IS on disk, but the
+ *  frontmatter projects/people/tags arrays are empty. */
+export type PartialExtractReason = "frontmatter_tag_missing" | "frontmatter_invalid_json" | "frontmatter_schema_invalid";
+/** Terminal — no daily file was written. */
+export type ExtractionFailureReason = "stage_b_null" | "empty_output" | "body_tag_missing" | "write_failed";
+export type JournalParseError = ExtractionFailureReason | PartialExtractReason;
+export interface ExtractJournalSectionsResult {
+    body: string | null;
+    frontmatter: JournalFrontmatter | null;
+    parseError: JournalParseError | null;
+}
+export type DailyJournalComposeMode = "put" | "append_revision";
+export type DailyJournalComposeResult = {
+    ok: "complete";
+    bytesWritten: number;
+    wroteMode: DailyJournalComposeMode;
+} | {
+    ok: "partial";
+    bytesWritten: number;
+    wroteMode: DailyJournalComposeMode;
+    partialReason: PartialExtractReason;
+} | {
+    ok: false;
+    reason: ExtractionFailureReason;
+};
+/**
+ * Walk `output` and return the body + frontmatter blocks the LLM
+ * emitted. Pure — every output byte is a deterministic function of the
+ * input. Exposed for unit tests so the extraction branches can be
+ * pinned without the fs / DB harness.
+ *
+ * Boundary rules per design §4.4:
+ *   - Opening / closing tags are matched on their own line (with
+ *     optional surrounding whitespace).
+ *   - Content between the tags is the literal byte stream — no escape
+ *     processing.
+ *   - When multiple openings appear, the LAST matched pair wins. The
+ *     `aitne:` namespace + the "wrappers AT THE END of your output"
+ *     task-flow instruction give two layers of collision defence.
+ *   - Code-fence wrapping around tags (` ```xml\n<aitne:...>\n```` `)
+ *     is tolerated — fences are stripped before parsing.
+ */
+export declare function extractJournalSections(output: string | null | undefined): ExtractJournalSectionsResult;
+/**
+ * Locate the LAST `<tagName>...</tagName>` pair in `body` (per the
+ * collision-resistance policy above) and return the inner bytes.
+ *
+ * `<tagName>` and `</tagName>` must each be on their own line (optional
+ * surrounding whitespace allowed). The returned string is the literal
+ * byte stream between them — leading/trailing newlines stripped to
+ * match the YAML / markdown idiom (`<tag>\n<content>\n</tag>` should
+ * yield `<content>`, not `\n<content>\n`).
+ *
+ * Tolerates a code-fence wrapper around either tag (`\`\`\`xml\n<tag>`),
+ * which Haiku is known to emit when prompted with structured output
+ * instructions. The fence-strip is line-local — only fence lines
+ * immediately adjacent to the tag line are stripped.
+ */
+export declare function extractLastTaggedBlock(body: string, tagName: string): string | null;
+/**
+ * Compose the final `daily/<date>.md` byte stream from the skeleton-owned
+ * frontmatter facts + the LLM-supplied frontmatter fields + the
+ * LLM-supplied body. Pure — every output byte is a deterministic
+ * function of the inputs.
+ *
+ * YAML serialisation policy per design §4.6: list form (not flow form)
+ * for `plans/projects/people/tags`, fixed key order regardless of input
+ * property order, empty arrays render as `field: []`.
+ *
+ * Daemon-owned + immutable: date, weekday, type, owner, agent_generated,
+ * calendar_events, messages_handled, updated, agent_last_synced_at,
+ * content_hash. The LLM has no influence over any of these.
+ */
+export declare function composeDailyJournal(args: {
+    skeleton: JournalSkeletonInputs;
+    /** Count of yesterday's calendar events, taken from the skeleton facts. */
+    calendarEvents: number;
+    /** `messages_handled` count, taken from the skeleton facts. */
+    messagesHandled: number;
+    body: string;
+    frontmatter: JournalFrontmatter;
+    /** Stamped `Date.now()` ISO8601 — daemon owns this per §4.6. */
+    agentLastSyncedAtIso: string;
+}): string;
+/**
+ * Render the H2 header for the append-revision branch. Pulled out so
+ * the orchestrator + tests share one source of truth for the format.
+ */
+export declare function dailyJournalRevisionHeader(isoTimestamp: string): string;
+export interface DailyJournalComposerDeps {
+    db: Database.Database;
+    contextDir: string;
+    saveSnapshot: (snapshotKey: string, content: string, trigger: string, force?: boolean, sessionId?: string | null) => number | null;
+    writeTracker?: Pick<AgentWriteTracker, "markWriting" | "unmark">;
+    onIndexableContextChange?: (relativePath: string) => void;
+    /** Override `Date.now()` for tests. */
+    now?: () => Date;
+}
+export interface DailyJournalComposeArgs {
+    /** Routine correlation id — used for log correlation only. */
+    correlationId: string;
+    /** Yesterday's agent-day date (`YYYY-MM-DD`). */
+    yesterdayDateStr: string;
+    /** Pre-built skeleton inputs the orchestrator already computed. */
+    skeleton: JournalSkeletonInputs;
+    /** Pre-aggregated `calendar_events` count (from skeleton facts). */
+    calendarEvents: number;
+    /** Pre-aggregated `messages_handled` count (from skeleton facts). */
+    messagesHandled: number;
+    /** Stage B's `AgentResult` — `null` when Stage B was skipped or threw
+     *  (the composer returns `ok: false, reason: "stage_b_null"` directly). */
+    stageBResult: AgentResult | null;
+}
+/**
+ * Wired composer — extract → compose → write. Returns the discriminated
+ * outcome so the orchestrator can plumb `detail.dailyWrite` into the
+ * Stage B `agent_actions` row before persisting and so the appender can
+ * render the right line.
+ *
+ * Errors are NOT thrown for any LLM-shape failure — those are returned
+ * as `ok: false`. fs / DB errors during the write itself ARE caught and
+ * returned as `ok: false, reason: "write_failed"`; the caller does not
+ * need a try/catch around `compose()` calls.
+ */
+export declare class DailyJournalComposer {
+    private readonly deps;
+    constructor(deps: DailyJournalComposerDeps);
+    compose(args: DailyJournalComposeArgs): Promise<DailyJournalComposeResult>;
+    private helperDeps;
+}