@hyperdrive.bot/paseo-server 0.3.10 → 0.3.12

package/dist/server/server/agent/agent-loading.js

@@ -1,4 +1,5 @@
 import { buildConfigOverrides, buildSessionConfig, extractTimestamps, isStoredAgentProviderAvailable, toAgentPersistenceHandle, } from "../persistence-hooks.js";
+import { resolveUsableResumeCwd } from "./resolve-resume-cwd.js";
 const pendingAgentInitializations = new Map();
 export async function ensureAgentLoaded(agentId, deps) {
     const existing = deps.agentManager.getAgent(agentId);
@@ -19,18 +20,38 @@ export async function ensureAgentLoaded(agentId, deps) {
             throw new Error(`Agent ${agentId} references unavailable provider '${record.provider}'`);
         }
         const handle = toAgentPersistenceHandle(validProviders, record.persistence);
+        // A recorded cwd may no longer exist: the worktree was cleaned up, or the
+        // session came from another machine (`/Users/claudinho/...` on a linux box).
+        // normalizeConfig stats the cwd and throws "Working directory does not
+        // exist", so loading the agent fails outright and every READ of that session
+        // fails with it, including get_agent_activity, even though the transcript is
+        // sitting on disk and perfectly readable.
+        //
+        // The interactive resume path in session.ts already solves this with
+        // resolveUsableResumeCwd. ensureAgentLoaded did not, so schedules and the
+        // Jarvis judge hit the wall instead. Measured 2026-07-31: 27 of 1,226 agents
+        // were unreadable for this reason alone.
+        //
+        // Resuming does not need the original directory, only *a* valid one: the
+        // transcript is read from the provider store regardless.
+        const resolvedCwd = record.cwd ? await resolveUsableResumeCwd(record.cwd) : null;
+        if (resolvedCwd?.substituted) {
+            deps.logger.warn({ agentId, original: resolvedCwd.original, fallback: resolvedCwd.cwd }, "Agent cwd no longer exists; loading against an existing directory instead");
+        }
+        const cwdOverride = resolvedCwd?.substituted ? { cwd: resolvedCwd.cwd } : {};
         let snapshot;
         if (handle) {
-            snapshot = await deps.agentManager.resumeAgentFromPersistence(handle, buildConfigOverrides(record), agentId, extractTimestamps(record));
+            snapshot = await deps.agentManager.resumeAgentFromPersistence(handle, { ...buildConfigOverrides(record), ...cwdOverride }, agentId, extractTimestamps(record));
             deps.logger.info({ agentId, provider: record.provider }, "Agent resumed from persistence");
         }
         else {
-            const config = buildSessionConfig(record, {
+            const baseConfig = buildSessionConfig(record, {
                 validProviders,
             });
-            if (!config) {
+            if (!baseConfig) {
                 throw new Error(`Agent ${agentId} references unavailable provider '${record.provider}'`);
             }
+            const config = { ...baseConfig, ...cwdOverride };
             snapshot = await deps.agentManager.createAgent(config, agentId, {
                 labels: record.labels,
                 workspaceId: record.workspaceId,

package/dist/server/server/agent/agent-manager.d.ts

@@ -4,6 +4,8 @@ import type { Logger } from "pino";
 import type { TerminalManager } from "../../terminal/terminal-manager.js";
 import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, type AgentSlashCommand, type AgentMode, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentPersistenceHandle, type AgentProviderNotice, type AgentPromptInput, type AgentProvider, type AgentRunOptions, type AgentRunResult, type AgentSession, type AgentSessionConfig, type AgentStreamEvent, type AgentTimelineItem, type AgentUsage, type AgentRuntimeInfo, type ImportableProviderSession, type ListImportableSessionsOptions } from "./agent-sdk-types.js";
 import type { StoredAgentRecord, AgentStorage } from "./agent-storage.js";
+import { type CardMoveLog } from "./card-move-log.js";
+import type { BlockerLog } from "./blocker-log.js";
 import type { AgentTimelineFetchOptions, AgentTimelineFetchResult, AgentTimelineRow, AgentTimelineStore } from "./agent-timeline-store-types.js";
 import { type ForegroundTurnWaiter } from "./foreground-run-state.js";
 import { type RewindMode } from "./rewind/rewind.js";
@@ -85,6 +87,10 @@ export interface AgentManagerOptions {
     appendSystemPrompt?: string;
     agentStreamCoalesceWindowMs?: number;
     rescueTimeouts?: AgentManagerRescueTimeouts;
+    /** Jarvis substrate (JARVIS-V1-SPEC §3.2). Optional: absent = no move logging. */
+    cardMoveLog?: CardMoveLog;
+    /** Jarvis substrate: blocker history. Optional: absent = no blocker logging. */
+    blockerLog?: BlockerLog;
     logger: Logger;
 }
 export interface WaitForAgentOptions {
@@ -207,6 +213,10 @@ export declare class AgentManager {
     private readonly subscribers;
     private readonly idFactory;
     private readonly registry?;
+    /** Jarvis substrate (JARVIS-V1-SPEC §3.2). Absent in tests and older callers. */
+    private readonly cardMoveLog?;
+    /** Jarvis substrate: blocker history. Absent in tests and older callers. */
+    private readonly blockerLog?;
     private readonly durableTimelineStore?;
     private readonly previousStatuses;
     private readonly backgroundTasks;
@@ -265,6 +275,12 @@ export declare class AgentManager {
     listDraftFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     getAgent(id: string): ManagedAgent | null;
     getTimeline(id: string): AgentTimelineItem[];
+    /**
+     * Timeline epoch for an agent. Row `seq` restarts at 1 whenever the store is
+     * re-initialized without seeded rows, so a seq is only comparable WITHIN an
+     * epoch. Anything caching a high-water seq must cache this alongside it.
+     */
+    getTimelineEpoch(id: string): string;
     getTimelineRows(id: string): Promise<AgentTimelineRow[]>;
     fetchTimeline(id: string, options?: AgentTimelineFetchOptions): AgentTimelineFetchResult;
     createAgent(config: AgentSessionConfig, agentId?: string, options?: {
@@ -331,6 +347,12 @@ export declare class AgentManager {
     setAgentFeature(agentId: string, featureId: string, value: unknown): Promise<void>;
     setTitle(agentId: string, title: string): Promise<void>;
     setLabels(agentId: string, labels: Record<string, string>): Promise<void>;
+    /**
+     * The single chokepoint for every label write (JARVIS-V1-SPEC §3.2). Both the
+     * live-agent branch and the detached-record branch flow through here, which is
+     * why the card-move hook lives at this level and not on the public `setLabels`
+     * (that one misses the detached path entirely).
+     */
     private writeLabels;
     private writeStoredMetadata;
     detachAgent(agentId: string): Promise<{

package/dist/server/server/agent/agent-manager.js

@@ -6,6 +6,7 @@ import { getParentAgentIdFromLabels, isDelegatedAgent, PARENT_AGENT_ID_LABEL, }
 import { z } from "zod";
 import { getAgentStreamEventTurnId, } from "./agent-sdk-types.js";
 import { buildArchivedAgentRecord } from "./agent-archive.js";
+import { KANBAN_LABEL_KEY } from "./card-move-log.js";
 import { InMemoryAgentTimelineStore, } from "./agent-timeline-store.js";
 import { AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS, AgentStreamCoalescer, } from "./agent-stream-coalescer.js";
 import { ForegroundRunState } from "./foreground-run-state.js";
@@ -200,6 +201,10 @@ export class AgentManager {
         this.appendSystemPrompt = "";
         this.idFactory = options?.idFactory ?? (() => randomUUID());
         this.registry = options?.registry;
+        // Plain access, not `options?.`: the optional chain counts as a branch and
+        // tips this constructor over the oxlint complexity ceiling of 20.
+        this.cardMoveLog = options.cardMoveLog;
+        this.blockerLog = options.blockerLog;
         this.durableTimelineStore = options?.durableTimelineStore;
         if (options?.onAgentAttention) {
             this.attentionListeners.add(options.onAgentAttention);
@@ -510,6 +515,14 @@ export class AgentManager {
         this.requireAgent(id);
         return this.timelineStore.getItems(id);
     }
+    /**
+     * Timeline epoch for an agent. Row `seq` restarts at 1 whenever the store is
+     * re-initialized without seeded rows, so a seq is only comparable WITHIN an
+     * epoch. Anything caching a high-water seq must cache this alongside it.
+     */
+    getTimelineEpoch(id) {
+        return this.timelineStore.getEpoch(id);
+    }
     async getTimelineRows(id) {
         this.requireAgent(id);
         if (this.durableTimelineStore) {
@@ -1019,17 +1032,35 @@ export class AgentManager {
         const agent = this.requireAgent(agentId);
         await this.writeLabels(agent.id, labels);
     }
+    /**
+     * The single chokepoint for every label write (JARVIS-V1-SPEC §3.2). Both the
+     * live-agent branch and the detached-record branch flow through here, which is
+     * why the card-move hook lives at this level and not on the public `setLabels`
+     * (that one misses the detached path entirely).
+     */
     async writeLabels(agentId, patch) {
+        // Only pay for a before-read when the patch could actually move the card.
+        const touchesColumn = Object.prototype.hasOwnProperty.call(patch, KANBAN_LABEL_KEY);
         const liveAgent = this.agents.get(agentId);
         if (liveAgent) {
+            const beforeColumn = touchesColumn ? (liveAgent.labels[KANBAN_LABEL_KEY] ?? null) : null;
             liveAgent.labels = applyLabelPatch(liveAgent.labels, patch);
             this.touchUpdatedAt(liveAgent);
             await this.persistSnapshot(liveAgent);
             this.emitState(liveAgent, { persist: false });
+            if (touchesColumn) {
+                this.cardMoveLog?.record(agentId, beforeColumn, liveAgent.labels[KANBAN_LABEL_KEY] ?? null);
+            }
             const record = this.registry ? await this.registry.get(agentId) : null;
             return { record, live: true };
         }
+        const priorColumn = touchesColumn && this.registry
+            ? ((await this.registry.get(agentId))?.labels?.[KANBAN_LABEL_KEY] ?? null)
+            : null;
         const nextRecord = await this.writeStoredMetadata(agentId, { labels: patch });
+        if (touchesColumn) {
+            this.cardMoveLog?.record(agentId, priorColumn, nextRecord.labels?.[KANBAN_LABEL_KEY] ?? null);
+        }
         return { record: nextRecord, live: false };
     }
     async writeStoredMetadata(agentId, patch) {
@@ -1096,6 +1127,11 @@ export class AgentManager {
         const registry = this.requireRegistry();
         const persisted = await registry.setDigest(agentId, digest);
         agent.updatedAt = new Date(persisted.updatedAt);
+        // Jarvis substrate: mergeDigest overwrites blockers on every derivation, so
+        // without this append the "fourth time waiting on Marco" signal is destroyed
+        // on every idle. Self-reported blockers win over derived ones, matching how
+        // the judge reads them.
+        this.blockerLog?.record(agentId, digest.blockers?.length ? digest.blockers : digest.derivedBlockers);
         this.emitState(agent, { persist: false });
     }
     notifyAgentState(agentId) {

package/dist/server/server/agent/agent-storage.d.ts

@@ -36,6 +36,15 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
         accomplishments: z.ZodOptional<z.ZodArray<z.ZodString>>;
         selfReportedAt: z.ZodOptional<z.ZodString>;
         generatedAt: z.ZodOptional<z.ZodString>;
+        derivedNextStep: z.ZodOptional<z.ZodString>;
+        derivedBlockers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        urgency: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            normal: "normal";
+            high: "high";
+        }>>;
+        deadline: z.ZodOptional<z.ZodString>;
+        derivedDeadline: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     lastStatus: z.ZodDefault<z.ZodEnum<{
         error: "error";

package/dist/server/server/agent/blocker-log.d.ts

@@ -0,0 +1,81 @@
+import type { Logger } from "pino";
+/**
+ * Append-only blocker history (JARVIS-V1-SPEC, follow-up to §3.2).
+ *
+ * WHY THIS EXISTS, and why the card-move log does not cover it.
+ *
+ * The move log answers "how many times was this card DEFERRED", counting column
+ * transitions. The sentence the product actually wants is different:
+ *
+ *     "that is the fourth time you have been waiting on Marco"
+ *
+ * That needs a history of WHO or WHAT has been blocking, not of where the card
+ * sat. Those are different claims and the move log cannot produce the second one.
+ *
+ * Without this, blockers live only on `digest.blockers` / `digest.derivedBlockers`,
+ * and `mergeDigest` OVERWRITES both on every derivation. So the signal that makes
+ * the killer feature land is destroyed on every idle. Like the move log, this is
+ * PROSPECTIVE ONLY: nothing before it ships is recoverable.
+ *
+ * ## Deliberately no fuzzy matching here
+ *
+ * The obvious next step is to parse "Marco" out of the text and count mentions.
+ * That is resisted on purpose. A model rewording a blocker between derivations
+ * ("waiting on Marco Marques to confirm the VPN org mapping" vs "blocked pending
+ * Marco's confirmation") would break any regex or exact-match counter, and it
+ * would break SILENTLY, under-counting and making the nag weaker exactly when the
+ * blocker is most persistent.
+ *
+ * So this module stores blockers VERBATIM with timestamps and does no semantic
+ * work at all. The judge is already a language model reading a briefing; counting
+ * "this is the fourth distinct time Marco has come up" is precisely what it is
+ * good at and what a daemon is bad at. Keep the intelligence at the reader.
+ */
+export interface BlockerRow {
+    cardId: string;
+    /** Verbatim blocker strings as recorded at that moment. Never normalized. */
+    blockers: string[];
+    /** ISO timestamp. */
+    at: string;
+}
+export interface BlockerLogOptions {
+    /** Directory to write into, normally $PASEO_HOME. */
+    dir: string;
+    logger: Logger;
+    /** Test seam. Defaults to `() => new Date()`. */
+    now?: () => Date;
+}
+export declare class BlockerLog {
+    private readonly filePath;
+    private readonly logger;
+    private readonly now;
+    private ensured;
+    constructor(options: BlockerLogOptions);
+    /**
+     * Record the current blocker set for a card. No-ops when the set is unchanged
+     * from the last recording, so callers can hand us every digest write.
+     *
+     * NEVER throws. A digest write must not fail because bookkeeping failed.
+     */
+    record(cardId: string, blockers: readonly string[] | undefined): void;
+    /** All rows, oldest first. Returns [] when the log does not exist yet. */
+    readAll(): BlockerRow[];
+    /** Rows for one card, oldest first. */
+    history(cardId: string): BlockerRow[];
+    /** The most recent recording for a card, or null. */
+    latest(cardId: string): BlockerRow | null;
+    /**
+     * How many separate times this card has been recorded as blocked by anything.
+     * A coarse count only. It deliberately does NOT try to say "how many times by
+     * Marco specifically", because that is a semantic question, see the module note.
+     */
+    blockedRecordings(cardId: string): number;
+    /**
+     * Compact history for a judge briefing: one line per distinct recording,
+     * oldest first, capped. Handing the model the raw timeline lets it say "fourth
+     * time on Marco" itself rather than us guessing at entity matching.
+     */
+    renderTimeline(cardId: string, max?: number): string[];
+    private ensureDir;
+}
+//# sourceMappingURL=blocker-log.d.ts.map

package/dist/server/server/agent/blocker-log.js

@@ -0,0 +1,113 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** Change detection only. NOT used for matching or counting. */
+function fingerprint(blockers) {
+    return blockers
+        .map((b) => b.trim().toLowerCase())
+        .filter(Boolean)
+        .sort()
+        .join("\u0000");
+}
+export class BlockerLog {
+    constructor(options) {
+        this.ensured = false;
+        this.filePath = path.join(options.dir, "blockers.jsonl");
+        this.logger = options.logger;
+        this.now = options.now ?? (() => new Date());
+    }
+    /**
+     * Record the current blocker set for a card. No-ops when the set is unchanged
+     * from the last recording, so callers can hand us every digest write.
+     *
+     * NEVER throws. A digest write must not fail because bookkeeping failed.
+     */
+    record(cardId, blockers) {
+        const next = (blockers ?? []).map((b) => b.trim()).filter(Boolean);
+        const previous = this.latest(cardId);
+        // An empty set is worth recording once: "the blocker cleared" is real news,
+        // and it is what lets a reader see that a card came unstuck and got stuck again.
+        if (previous && fingerprint(previous.blockers) === fingerprint(next)) {
+            return;
+        }
+        if (!previous && next.length === 0) {
+            return;
+        }
+        const row = { cardId, blockers: next, at: this.now().toISOString() };
+        try {
+            this.ensureDir();
+            fs.appendFileSync(this.filePath, `${JSON.stringify(row)}\n`, "utf8");
+        }
+        catch (error) {
+            this.logger.error({ err: error, cardId }, "Blocker log append failed");
+        }
+    }
+    /** All rows, oldest first. Returns [] when the log does not exist yet. */
+    readAll() {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.filePath, "utf8");
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code !== "ENOENT") {
+                this.logger.error({ err: error }, "Blocker log read failed");
+            }
+            return [];
+        }
+        const rows = [];
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (typeof parsed?.cardId === "string" && Array.isArray(parsed?.blockers)) {
+                    rows.push(parsed);
+                }
+            }
+            catch {
+                // A torn trailing line must not poison the whole read.
+                continue;
+            }
+        }
+        return rows;
+    }
+    /** Rows for one card, oldest first. */
+    history(cardId) {
+        return this.readAll().filter((row) => row.cardId === cardId);
+    }
+    /** The most recent recording for a card, or null. */
+    latest(cardId) {
+        const rows = this.history(cardId);
+        return rows.length > 0 ? rows[rows.length - 1] : null;
+    }
+    /**
+     * How many separate times this card has been recorded as blocked by anything.
+     * A coarse count only. It deliberately does NOT try to say "how many times by
+     * Marco specifically", because that is a semantic question, see the module note.
+     */
+    blockedRecordings(cardId) {
+        return this.history(cardId).filter((r) => r.blockers.length > 0).length;
+    }
+    /**
+     * Compact history for a judge briefing: one line per distinct recording,
+     * oldest first, capped. Handing the model the raw timeline lets it say "fourth
+     * time on Marco" itself rather than us guessing at entity matching.
+     */
+    renderTimeline(cardId, max = 6) {
+        const rows = this.history(cardId);
+        return rows.slice(-max).map((r) => {
+            const day = r.at.slice(0, 10);
+            return r.blockers.length === 0 ? `${day}: cleared` : `${day}: ${r.blockers.join(" | ")}`;
+        });
+    }
+    ensureDir() {
+        if (this.ensured) {
+            return;
+        }
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        this.ensured = true;
+    }
+}
+//# sourceMappingURL=blocker-log.js.map

package/dist/server/server/agent/card-move-log.d.ts

@@ -0,0 +1,66 @@
+import type { Logger } from "pino";
+/**
+ * Append-only kanban card-move log (JARVIS-V1-SPEC §3.2).
+ *
+ * Why this exists: column membership rides on the agent label `labels.kanban`,
+ * and `labels.kanban_enteredAt` holds only the CURRENT value, overwritten on
+ * every move. There is no move history anywhere, so "fourth time you have
+ * deferred this" is unwritable. This log is the deferral history.
+ *
+ * It is PROSPECTIVE ONLY. Nothing before it ships is recoverable, which is why
+ * the spec sequences it ahead of everything else.
+ *
+ * Durability model: newline-delimited JSON appended to a single file under
+ * $PASEO_HOME. Append is atomic enough for our purposes (single writer process,
+ * one `appendFileSync` per row, rows are far below PIPE_BUF), and a torn final
+ * line is tolerated by the reader rather than being allowed to poison a read.
+ */
+export interface CardMoveRow {
+    cardId: string;
+    /** Previous column. Null on first placement. */
+    fromColumn: string | null;
+    /** New column. Null when the card was removed from the board entirely. */
+    toColumn: string | null;
+    /** ISO timestamp. */
+    at: string;
+}
+export interface CardMoveLogOptions {
+    /** Directory to write into, normally $PASEO_HOME. */
+    dir: string;
+    logger: Logger;
+    /** Test seam. Defaults to `() => new Date()`. */
+    now?: () => Date;
+}
+export declare class CardMoveLog {
+    private readonly filePath;
+    private readonly logger;
+    private readonly now;
+    private ensured;
+    constructor(options: CardMoveLogOptions);
+    /**
+     * Record a column change. No-ops when the column did not actually change, so
+     * callers can hand us every label write without filtering first.
+     *
+     * NEVER throws. A label write must not fail because bookkeeping failed.
+     */
+    record(cardId: string, fromColumn: string | null, toColumn: string | null): void;
+    /** All rows, oldest first. Returns [] when the log does not exist yet. */
+    readAll(): CardMoveRow[];
+    /** Rows for one card, oldest first. */
+    history(cardId: string): CardMoveRow[];
+    /**
+     * How many times this card has been pushed away from active work.
+     *
+     * Counts transitions from an active column (now/urgent/verify) into a
+     * deferral column (later/future/awaiting). A card that has never been active
+     * and simply sits in `later` has not been deferred, it has merely never been
+     * picked up, and conflating those two would make the judge's headline number
+     * a lie.
+     */
+    deferralCount(cardId: string): number;
+    /** When the card last entered its current column, from the log. Null if unknown. */
+    lastMoveAt(cardId: string): string | null;
+    private ensureDir;
+}
+export declare const KANBAN_LABEL_KEY = "kanban";
+//# sourceMappingURL=card-move-log.d.ts.map

package/dist/server/server/agent/card-move-log.js

@@ -0,0 +1,113 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** Columns that mean "pushed away from now", used for the deferral count. */
+const DEFERRAL_TARGETS = new Set(["later", "future", "awaiting"]);
+/** Columns that mean "actively committed to". */
+const ACTIVE_SOURCES = new Set(["now", "urgent", "verify"]);
+export class CardMoveLog {
+    constructor(options) {
+        this.ensured = false;
+        this.filePath = path.join(options.dir, "card-moves.jsonl");
+        this.logger = options.logger;
+        this.now = options.now ?? (() => new Date());
+    }
+    /**
+     * Record a column change. No-ops when the column did not actually change, so
+     * callers can hand us every label write without filtering first.
+     *
+     * NEVER throws. A label write must not fail because bookkeeping failed.
+     */
+    record(cardId, fromColumn, toColumn) {
+        const from = fromColumn ?? null;
+        const to = toColumn ?? null;
+        if (from === to) {
+            return;
+        }
+        const row = {
+            cardId,
+            fromColumn: from,
+            toColumn: to,
+            at: this.now().toISOString(),
+        };
+        try {
+            this.ensureDir();
+            fs.appendFileSync(this.filePath, `${JSON.stringify(row)}\n`, "utf8");
+        }
+        catch (error) {
+            // Deliberately swallowed. Losing a log row is bad; failing the user's
+            // card move because we could not log it is worse.
+            this.logger.error({ err: error, cardId, from, to }, "Card move log append failed");
+        }
+    }
+    /** All rows, oldest first. Returns [] when the log does not exist yet. */
+    readAll() {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.filePath, "utf8");
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code !== "ENOENT") {
+                this.logger.error({ err: error }, "Card move log read failed");
+            }
+            return [];
+        }
+        const rows = [];
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (typeof parsed?.cardId === "string" && typeof parsed?.at === "string") {
+                    rows.push(parsed);
+                }
+            }
+            catch {
+                // A torn trailing line (crash mid-append) must not poison the whole read.
+                continue;
+            }
+        }
+        return rows;
+    }
+    /** Rows for one card, oldest first. */
+    history(cardId) {
+        return this.readAll().filter((row) => row.cardId === cardId);
+    }
+    /**
+     * How many times this card has been pushed away from active work.
+     *
+     * Counts transitions from an active column (now/urgent/verify) into a
+     * deferral column (later/future/awaiting). A card that has never been active
+     * and simply sits in `later` has not been deferred, it has merely never been
+     * picked up, and conflating those two would make the judge's headline number
+     * a lie.
+     */
+    deferralCount(cardId) {
+        let count = 0;
+        for (const row of this.history(cardId)) {
+            if (row.fromColumn &&
+                ACTIVE_SOURCES.has(row.fromColumn) &&
+                row.toColumn &&
+                DEFERRAL_TARGETS.has(row.toColumn)) {
+                count += 1;
+            }
+        }
+        return count;
+    }
+    /** When the card last entered its current column, from the log. Null if unknown. */
+    lastMoveAt(cardId) {
+        const history = this.history(cardId);
+        return history.length > 0 ? history[history.length - 1].at : null;
+    }
+    ensureDir() {
+        if (this.ensured) {
+            return;
+        }
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        this.ensured = true;
+    }
+}
+export const KANBAN_LABEL_KEY = "kanban";
+//# sourceMappingURL=card-move-log.js.map