@basou/core 0.41.0 → 0.42.0

package/dist/index.js

@@ -354,6 +354,251 @@ function isValidPrefixedId(value) {
   return isValidUlid(ulidPart);
 }
 
+// src/schemas/event.schema.ts
+import { z as z2 } from "zod";
+
+// src/schemas/shared.schema.ts
+import { z } from "zod";
+var SchemaVersionSchema = z.string().regex(/^0\.\d+\.\d+$/, {
+  message: "unsupported .basou format version: this basou reads format major 0 (0.x.y). If this workspace was written by a newer basou, upgrade basou to open it."
+});
+var CacheVersionSchema = z.literal("0.1.0");
+var IsoTimestampSchema = z.string().datetime({ offset: true });
+var createPrefixedIdSchema = (prefix) => {
+  const refiner = (value) => isValidPrefixedId(value) && value.startsWith(`${prefix}_`);
+  return z.string().refine(refiner, { message: `Expected ${prefix}_<ULID>` }).meta({
+    pattern: `^${prefix}_[0-7][0-9A-HJKMNP-TV-Z]{25}$`,
+    description: `Basou ${prefix} id: \`${prefix}_\` followed by a 26-character Crockford Base32 ULID.`
+  });
+};
+var WorkspaceIdSchema = createPrefixedIdSchema("ws");
+var TaskIdSchema = createPrefixedIdSchema("task");
+var SessionIdSchema = createPrefixedIdSchema("ses");
+var EventIdSchema = createPrefixedIdSchema("evt");
+var ApprovalIdSchema = createPrefixedIdSchema("appr");
+var DecisionIdSchema = createPrefixedIdSchema("decision");
+var RiskLevelSchema = z.enum(["low", "medium", "high", "critical"]);
+var EventSourceSchema = z.string().min(1);
+
+// src/schemas/event.schema.ts
+var EVENT_SCHEMA_VERSION = "0.2.0";
+var BaseEventSchema = z2.object({
+  schema_version: SchemaVersionSchema,
+  id: EventIdSchema,
+  session_id: SessionIdSchema,
+  occurred_at: IsoTimestampSchema,
+  source: EventSourceSchema,
+  // Tamper-evidence back-pointer (hex sha-256 of the PREVIOUS event line's
+  // written bytes; the first line carries the session-bound genesis hash).
+  // Present only on sessions written with chaining enabled (import paths);
+  // live/ad-hoc sessions omit it. Declared on the base so the `.strict()`
+  // variants below treat it as a known key. Additive optional => no
+  // schema_version bump.
+  prev_hash: z2.string().optional()
+});
+var SessionStartedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("session_started")
+});
+var SessionEndedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("session_ended"),
+  exit_code: z2.number().int().optional()
+});
+var SessionStatusChangedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("session_status_changed"),
+  from: z2.string(),
+  to: z2.string()
+});
+var ApprovalRequestedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("approval_requested"),
+  approval_id: ApprovalIdSchema,
+  expires_at: IsoTimestampSchema.nullable().default(null),
+  risk_level: RiskLevelSchema,
+  // `action.kind` is required; additional fields are allowed to support
+  // future action shapes (shell_command, external_send, ...).
+  action: z2.object({ kind: z2.string() }).passthrough(),
+  reason: z2.string(),
+  status: z2.literal("pending")
+});
+var ApprovalApprovedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("approval_approved"),
+  approval_id: ApprovalIdSchema,
+  resolver: z2.string().optional(),
+  note: z2.string().nullable().optional()
+});
+var ApprovalRejectedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("approval_rejected"),
+  approval_id: ApprovalIdSchema,
+  resolver: z2.string().optional(),
+  reason: z2.string()
+});
+var ApprovalExpiredEventSchema = BaseEventSchema.extend({
+  type: z2.literal("approval_expired"),
+  approval_id: ApprovalIdSchema
+});
+var CommandExecutedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("command_executed"),
+  command: z2.string().nullable().meta({
+    description: "Spawned executable name. null means basou did not observe the executor - not a default, and not a benign value."
+  }),
+  args: z2.array(z2.string()),
+  cwd: z2.string().nullable().meta({
+    description: "Working directory the command ran in. null means the directory could not be resolved; it is never the session's directory as a fallback."
+  }),
+  exit_code: z2.number().int().nullable().meta({
+    description: "Child exit code. null means the outcome is unknown (signal-terminated, or never recorded by the source). null is not success."
+  }),
+  signal: z2.string().nullable().optional(),
+  received_signal: z2.string().nullable().optional(),
+  // Still accepts 0, because 0.1.0 events carrying it are on disk and are never
+  // rewritten; every line read from disk is validated against this schema, so
+  // narrowing the domain here would silently drop them. Writers at 0.2.0 and
+  // above do not produce it.
+  duration_ms: z2.number().int().nonnegative().nullable().meta({
+    description: "Observed duration in milliseconds, or null when no duration was observed. Read 0 as unobserved too, on any version: a spawned process cannot run in under half a millisecond, and under schema_version 0.1.0 a writer with nothing to report stored 0 as the floor. Writers at 0.2.0 and above record null instead and never write 0."
+  })
+});
+var GitSnapshotEventSchema = BaseEventSchema.extend({
+  type: z2.literal("git_snapshot"),
+  head: z2.string(),
+  branch: z2.string(),
+  dirty: z2.boolean(),
+  staged: z2.array(z2.string()),
+  unstaged: z2.array(z2.string()),
+  untracked: z2.array(z2.string()),
+  ahead: z2.number().int().nonnegative().optional(),
+  behind: z2.number().int().nonnegative().optional()
+});
+var FileChangedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("file_changed"),
+  path: z2.string(),
+  change_type: z2.enum(["added", "modified", "deleted", "renamed"]),
+  // Renamed entries record the previous path here. Optional + nullable to
+  // keep the wire format stable for added / modified / deleted events.
+  old_path: z2.string().nullable().optional()
+});
+var DecisionRecordedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("decision_recorded"),
+  decision_id: DecisionIdSchema,
+  title: z2.string(),
+  rationale: z2.string().nullable().optional(),
+  alternatives: z2.array(z2.string().min(1)).optional(),
+  rejected_reason: z2.string().nullable().optional(),
+  linked_events: z2.array(EventIdSchema).optional(),
+  linked_files: z2.array(z2.string().min(1).max(4096)).optional(),
+  // `track` promotes a decision to a strategic, unfinished DIRECTION ("the next
+  // essential thing to build, and why") that orientation/handoff resurface every
+  // time until it is explicitly closed with `decision void` / supersede — as
+  // opposed to a point-in-time `decision`, which is only ever surfaced as the
+  // single latest one. This is the intent-continuity layer: a direction agreed
+  // in conversation otherwise sinks into the flat decision list and never carries
+  // to the next session. Absent (the default) is a plain `decision`, so all
+  // pre-existing decision_recorded events round-trip unchanged (additive optional
+  // => no schema_version bump; mirrors `note_added.kind`).
+  kind: z2.enum(["decision", "track"]).optional()
+});
+var DecisionVoidedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("decision_voided"),
+  decision_id: DecisionIdSchema,
+  reason: z2.string().nullable().optional(),
+  superseded_by: DecisionIdSchema.optional()
+});
+var TaskCreatedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("task_created"),
+  task_id: TaskIdSchema,
+  title: z2.string()
+});
+var TaskStatusChangedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("task_status_changed"),
+  task_id: TaskIdSchema,
+  from: z2.string(),
+  to: z2.string()
+});
+var TaskReconciledEventSchema = BaseEventSchema.extend({
+  type: z2.literal("task_reconciled"),
+  task_id: TaskIdSchema,
+  removed_created_in_session: SessionIdSchema.nullable().default(null),
+  created_in_session_replacement: SessionIdSchema.nullable().default(null),
+  removed_linked_sessions: z2.array(SessionIdSchema).default([])
+}).strict();
+var TaskLinkageRefreshedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("task_linkage_refreshed"),
+  task_id: TaskIdSchema,
+  added_linked_sessions: z2.array(SessionIdSchema).default([]),
+  removed_linked_sessions: z2.array(SessionIdSchema).default([]),
+  final_count: z2.number().int().nonnegative().optional()
+}).strict();
+var TaskDeletedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("task_deleted"),
+  task_id: TaskIdSchema,
+  title: z2.string().min(1)
+}).strict();
+var TaskArchivedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("task_archived"),
+  task_id: TaskIdSchema,
+  title: z2.string().min(1)
+}).strict();
+var NoteAddedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("note_added"),
+  body: z2.string(),
+  // `next_step` marks a note authored by `basou note` as the operator's resume
+  // hint, which orientation surfaces as the next starting point. Absent (the
+  // `basou session note` default) is a plain annotation orientation does not
+  // surface. Optional so pre-existing note_added events remain valid.
+  kind: z2.enum(["note", "next_step"]).optional()
+});
+var ReviewFindingSchema = z2.object({
+  title: z2.string().min(1),
+  severity: z2.enum(["high", "medium", "low"]).optional(),
+  location: z2.string().min(1).optional(),
+  summary: z2.string().min(1).optional()
+});
+var ReviewBlockedSchema = z2.object({
+  title: z2.string().min(1),
+  reason: z2.enum(["spec-deviation", "design-reversal"]),
+  why: z2.string().min(1).optional()
+});
+var ReviewRecordedEventSchema = BaseEventSchema.extend({
+  type: z2.literal("review_recorded"),
+  reviewer: z2.string().min(1),
+  target: z2.string().min(1),
+  repos: z2.array(z2.string().min(1)).optional(),
+  repos_resolved: z2.array(z2.string().min(1)).optional(),
+  commits: z2.array(z2.string().min(1)).optional(),
+  verdict: z2.enum(["pass", "needs-attention", "fail"]).optional(),
+  findings: z2.array(ReviewFindingSchema).optional(),
+  blocked: z2.array(ReviewBlockedSchema).optional()
+});
+var AdapterOutputEventSchema = BaseEventSchema.extend({
+  type: z2.literal("adapter_output"),
+  stream: z2.enum(["stdout", "stderr"]),
+  summary: z2.string(),
+  raw_ref: z2.string(),
+  redacted: z2.boolean().optional()
+}).strict();
+var EventSchema = z2.discriminatedUnion("type", [
+  SessionStartedEventSchema,
+  SessionEndedEventSchema,
+  SessionStatusChangedEventSchema,
+  ApprovalRequestedEventSchema,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  ApprovalExpiredEventSchema,
+  CommandExecutedEventSchema,
+  GitSnapshotEventSchema,
+  FileChangedEventSchema,
+  DecisionRecordedEventSchema,
+  DecisionVoidedEventSchema,
+  TaskCreatedEventSchema,
+  TaskStatusChangedEventSchema,
+  TaskReconciledEventSchema,
+  TaskLinkageRefreshedEventSchema,
+  TaskDeletedEventSchema,
+  TaskArchivedEventSchema,
+  NoteAddedEventSchema,
+  ReviewRecordedEventSchema,
+  AdapterOutputEventSchema
+]);
+
 // src/stats/active-time.ts
 var ACTIVE_GAP_CAP_MS = 5 * 60 * 1e3;
 var ENGAGED_TURNS_METHOD = "engaged-turns";
@@ -564,7 +809,7 @@ function claudeTranscriptToImportPayload(records, options) {
 }
 function baseEvent(occurredAt, sessionId) {
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: prefixedUlid("evt"),
     session_id: sessionId,
     occurred_at: occurredAt,
@@ -596,7 +841,9 @@ function commandExecutedEvent(occurredAt, sessionId, command, cwd) {
     // tool results across twelve transcripts). Reading it is its own change and
     // has not been made, so nothing is claimed here yet.
     exit_code: null,
-    duration_ms: 0
+    // Not observed: a Bash tool result carries no timing at all, so 0 here would
+    // claim a measured duration of zero for every imported command.
+    duration_ms: null
   };
 }
 function fileChangedEvent(occurredAt, sessionId, path2, changeType) {
@@ -789,6 +1036,44 @@ function findBasouSessionStartHook(hooksFile) {
   return null;
 }
 
+// src/schemas/observed-duration.ts
+function readObservedDuration(ev) {
+  const stored = ev.duration_ms;
+  if (stored === null || stored === 0) return null;
+  return stored;
+}
+function writeObservedDuration(measuredMs) {
+  if (measuredMs === null || !Number.isFinite(measuredMs)) return null;
+  const rounded = Math.round(measuredMs);
+  if (rounded <= 0) return null;
+  if (!Number.isSafeInteger(rounded)) return null;
+  return rounded;
+}
+var ZERO_DURATION_RETIRED_SINCE = "0.2.0";
+function hasRetiredZeroDuration(ev) {
+  if (ev.type !== "command_executed") return false;
+  if (ev.duration_ms !== 0) return false;
+  return compareSchemaVersion(ev.schema_version, ZERO_DURATION_RETIRED_SINCE) >= 0;
+}
+function compareSchemaVersion(a, b) {
+  const pa = parseSchemaVersion(a);
+  const pb = parseSchemaVersion(b);
+  if (pa === null) return pb === null ? 0 : -1;
+  if (pb === null) return 1;
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+function parseSchemaVersion(version) {
+  const parts = version.split(".");
+  if (parts.length !== 3) return null;
+  const nums = parts.map((part) => /^\d+$/.test(part) ? Number.parseInt(part, 10) : Number.NaN);
+  if (nums.some((n) => !Number.isFinite(n))) return null;
+  return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];
+}
+
 // src/adapters/codex/rollout-importer.ts
 var CODEX_IMPORT_SOURCE = "codex-import";
 function codexRolloutToImportPayload(records, options) {
@@ -846,7 +1131,7 @@ function codexRolloutToImportPayload(records, options) {
       const scan = scanScript(readString4(payload2.input));
       if (scan.commands.length === 0) continue;
       const output2 = readCallId(payload2.call_id, outputsByCallId);
-      const durationMs = scan.toolCallCount === 1 ? parseWallTimeMs(output2) : 0;
+      const durationMs = scan.toolCallCount === 1 ? parseWallTimeMs(output2) : null;
       const scriptTsMs = Date.parse(ts);
       if (Number.isFinite(scriptTsMs)) engagementTsMs.push(scriptTsMs);
       for (const command2 of scan.commands) {
@@ -875,10 +1160,17 @@ function codexRolloutToImportPayload(records, options) {
     const output = readCallId(payload2.call_id, outputsByCallId);
     const execTsMs = Date.parse(ts);
     if (Number.isFinite(execTsMs)) engagementTsMs.push(execTsMs);
+    const exitCode = parseExitCode(output);
     derived.push(
       commandExecutedEvent2(ts, placeholderSessionId, command.cmd, cwd, {
-        exitCode: parseExitCode(output),
-        durationMs: parseWallTimeMs(output)
+        exitCode,
+        // The duration is gated on the SAME token as the exit code. When this
+        // output reports no exit ("Process running with session ID N", or no
+        // outcome line at all), codex handed the turn back while the child was
+        // still running, so its `Wall time` is the interval codex waited and
+        // not how long the command took. A wall-clock duration cannot have been
+        // observed without observing that the process ended.
+        durationMs: exitCode === null ? null : parseWallTimeMs(output)
       })
     );
   }
@@ -955,7 +1247,7 @@ function codexRolloutToImportPayload(records, options) {
 }
 function baseEvent2(occurredAt, sessionId) {
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: prefixedUlid("evt"),
     session_id: sessionId,
     occurred_at: occurredAt,
@@ -1318,11 +1610,11 @@ function parseExitCode(output) {
   return match?.[1] !== void 0 ? Number.parseInt(match[1], 10) : null;
 }
 function parseWallTimeMs(output) {
-  if (output === void 0) return 0;
+  if (output === void 0) return null;
   const match = output.match(/Wall time:?\s*([\d.]+)\s*seconds/);
-  if (match?.[1] === void 0) return 0;
+  if (match?.[1] === void 0) return null;
   const seconds = Number.parseFloat(match[1]);
-  return Number.isFinite(seconds) ? Math.round(seconds * 1e3) : 0;
+  return writeObservedDuration(Number.isFinite(seconds) ? seconds * 1e3 : null);
 }
 function indexOutputs(records) {
   const byId = /* @__PURE__ */ new Map();
@@ -1361,50 +1653,25 @@ function findErrorCode(error, code, depth = 4) {
 }
 
 // src/schemas/approval.schema.ts
-import { z as z2 } from "zod";
-
-// src/schemas/shared.schema.ts
-import { z } from "zod";
-var SchemaVersionSchema = z.string().regex(/^0\.\d+\.\d+$/, {
-  message: "unsupported .basou format version: this basou reads format major 0 (0.x.y). If this workspace was written by a newer basou, upgrade basou to open it."
-});
-var CacheVersionSchema = z.literal("0.1.0");
-var IsoTimestampSchema = z.string().datetime({ offset: true });
-var createPrefixedIdSchema = (prefix) => {
-  const refiner = (value) => isValidPrefixedId(value) && value.startsWith(`${prefix}_`);
-  return z.string().refine(refiner, { message: `Expected ${prefix}_<ULID>` }).meta({
-    pattern: `^${prefix}_[0-7][0-9A-HJKMNP-TV-Z]{25}$`,
-    description: `Basou ${prefix} id: \`${prefix}_\` followed by a 26-character Crockford Base32 ULID.`
-  });
-};
-var WorkspaceIdSchema = createPrefixedIdSchema("ws");
-var TaskIdSchema = createPrefixedIdSchema("task");
-var SessionIdSchema = createPrefixedIdSchema("ses");
-var EventIdSchema = createPrefixedIdSchema("evt");
-var ApprovalIdSchema = createPrefixedIdSchema("appr");
-var DecisionIdSchema = createPrefixedIdSchema("decision");
-var RiskLevelSchema = z.enum(["low", "medium", "high", "critical"]);
-var EventSourceSchema = z.string().min(1);
-
-// src/schemas/approval.schema.ts
-var ApprovalStatusSchema = z2.enum(["pending", "approved", "rejected", "expired"]);
-var ApprovalSchema = z2.looseObject({
+import { z as z3 } from "zod";
+var ApprovalStatusSchema = z3.enum(["pending", "approved", "rejected", "expired"]);
+var ApprovalSchema = z3.looseObject({
   schema_version: SchemaVersionSchema,
   id: ApprovalIdSchema,
   session_id: SessionIdSchema,
   created_at: IsoTimestampSchema,
   status: ApprovalStatusSchema,
   risk_level: RiskLevelSchema,
-  action: z2.looseObject({ kind: z2.string() }).passthrough(),
-  reason: z2.string(),
+  action: z3.looseObject({ kind: z3.string() }).passthrough(),
+  reason: z3.string(),
   expires_at: IsoTimestampSchema.nullable().default(null),
   // The four fields below are null while `status === "pending"` and set
   // once a resolver records a decision. Defaulting to null keeps the
   // pending YAML free of explicit nulls if a producer omits them.
-  resolver: z2.string().nullable().default(null),
+  resolver: z3.string().nullable().default(null),
   resolved_at: IsoTimestampSchema.nullable().default(null),
-  note: z2.string().nullable().default(null),
-  rejection_reason: z2.string().nullable().default(null)
+  note: z3.string().nullable().default(null),
+  rejection_reason: z3.string().nullable().default(null)
 });
 
 // src/storage/yaml-store.ts
@@ -1536,221 +1803,12 @@ function isLazyExpired(approval, now) {
 
 // src/decisions/decisions-renderer.ts
 import { lstat as lstat2 } from "fs/promises";
-import { dirname as dirname2, join as join6, resolve } from "path";
+import { dirname as dirname2, join as join7, resolve } from "path";
 
 // src/events/event-replay.ts
 import { createReadStream } from "fs";
 import { stat } from "fs/promises";
 import { join as join2 } from "path";
-
-// src/schemas/event.schema.ts
-import { z as z3 } from "zod";
-var BaseEventSchema = z3.object({
-  schema_version: SchemaVersionSchema,
-  id: EventIdSchema,
-  session_id: SessionIdSchema,
-  occurred_at: IsoTimestampSchema,
-  source: EventSourceSchema,
-  // Tamper-evidence back-pointer (hex sha-256 of the PREVIOUS event line's
-  // written bytes; the first line carries the session-bound genesis hash).
-  // Present only on sessions written with chaining enabled (import paths);
-  // live/ad-hoc sessions omit it. Declared on the base so the `.strict()`
-  // variants below treat it as a known key. Additive optional => no
-  // schema_version bump.
-  prev_hash: z3.string().optional()
-});
-var SessionStartedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("session_started")
-});
-var SessionEndedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("session_ended"),
-  exit_code: z3.number().int().optional()
-});
-var SessionStatusChangedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("session_status_changed"),
-  from: z3.string(),
-  to: z3.string()
-});
-var ApprovalRequestedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("approval_requested"),
-  approval_id: ApprovalIdSchema,
-  expires_at: IsoTimestampSchema.nullable().default(null),
-  risk_level: RiskLevelSchema,
-  // `action.kind` is required; additional fields are allowed to support
-  // future action shapes (shell_command, external_send, ...).
-  action: z3.object({ kind: z3.string() }).passthrough(),
-  reason: z3.string(),
-  status: z3.literal("pending")
-});
-var ApprovalApprovedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("approval_approved"),
-  approval_id: ApprovalIdSchema,
-  resolver: z3.string().optional(),
-  note: z3.string().nullable().optional()
-});
-var ApprovalRejectedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("approval_rejected"),
-  approval_id: ApprovalIdSchema,
-  resolver: z3.string().optional(),
-  reason: z3.string()
-});
-var ApprovalExpiredEventSchema = BaseEventSchema.extend({
-  type: z3.literal("approval_expired"),
-  approval_id: ApprovalIdSchema
-});
-var CommandExecutedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("command_executed"),
-  command: z3.string().nullable(),
-  args: z3.array(z3.string()),
-  cwd: z3.string().nullable(),
-  exit_code: z3.number().int().nullable(),
-  signal: z3.string().nullable().optional(),
-  received_signal: z3.string().nullable().optional(),
-  duration_ms: z3.number().int().nonnegative()
-});
-var GitSnapshotEventSchema = BaseEventSchema.extend({
-  type: z3.literal("git_snapshot"),
-  head: z3.string(),
-  branch: z3.string(),
-  dirty: z3.boolean(),
-  staged: z3.array(z3.string()),
-  unstaged: z3.array(z3.string()),
-  untracked: z3.array(z3.string()),
-  ahead: z3.number().int().nonnegative().optional(),
-  behind: z3.number().int().nonnegative().optional()
-});
-var FileChangedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("file_changed"),
-  path: z3.string(),
-  change_type: z3.enum(["added", "modified", "deleted", "renamed"]),
-  // Renamed entries record the previous path here. Optional + nullable to
-  // keep the wire format stable for added / modified / deleted events.
-  old_path: z3.string().nullable().optional()
-});
-var DecisionRecordedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("decision_recorded"),
-  decision_id: DecisionIdSchema,
-  title: z3.string(),
-  rationale: z3.string().nullable().optional(),
-  alternatives: z3.array(z3.string().min(1)).optional(),
-  rejected_reason: z3.string().nullable().optional(),
-  linked_events: z3.array(EventIdSchema).optional(),
-  linked_files: z3.array(z3.string().min(1).max(4096)).optional(),
-  // `track` promotes a decision to a strategic, unfinished DIRECTION ("the next
-  // essential thing to build, and why") that orientation/handoff resurface every
-  // time until it is explicitly closed with `decision void` / supersede — as
-  // opposed to a point-in-time `decision`, which is only ever surfaced as the
-  // single latest one. This is the intent-continuity layer: a direction agreed
-  // in conversation otherwise sinks into the flat decision list and never carries
-  // to the next session. Absent (the default) is a plain `decision`, so all
-  // pre-existing decision_recorded events round-trip unchanged (additive optional
-  // => no schema_version bump; mirrors `note_added.kind`).
-  kind: z3.enum(["decision", "track"]).optional()
-});
-var DecisionVoidedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("decision_voided"),
-  decision_id: DecisionIdSchema,
-  reason: z3.string().nullable().optional(),
-  superseded_by: DecisionIdSchema.optional()
-});
-var TaskCreatedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("task_created"),
-  task_id: TaskIdSchema,
-  title: z3.string()
-});
-var TaskStatusChangedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("task_status_changed"),
-  task_id: TaskIdSchema,
-  from: z3.string(),
-  to: z3.string()
-});
-var TaskReconciledEventSchema = BaseEventSchema.extend({
-  type: z3.literal("task_reconciled"),
-  task_id: TaskIdSchema,
-  removed_created_in_session: SessionIdSchema.nullable().default(null),
-  created_in_session_replacement: SessionIdSchema.nullable().default(null),
-  removed_linked_sessions: z3.array(SessionIdSchema).default([])
-}).strict();
-var TaskLinkageRefreshedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("task_linkage_refreshed"),
-  task_id: TaskIdSchema,
-  added_linked_sessions: z3.array(SessionIdSchema).default([]),
-  removed_linked_sessions: z3.array(SessionIdSchema).default([]),
-  final_count: z3.number().int().nonnegative().optional()
-}).strict();
-var TaskDeletedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("task_deleted"),
-  task_id: TaskIdSchema,
-  title: z3.string().min(1)
-}).strict();
-var TaskArchivedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("task_archived"),
-  task_id: TaskIdSchema,
-  title: z3.string().min(1)
-}).strict();
-var NoteAddedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("note_added"),
-  body: z3.string(),
-  // `next_step` marks a note authored by `basou note` as the operator's resume
-  // hint, which orientation surfaces as the next starting point. Absent (the
-  // `basou session note` default) is a plain annotation orientation does not
-  // surface. Optional so pre-existing note_added events remain valid.
-  kind: z3.enum(["note", "next_step"]).optional()
-});
-var ReviewFindingSchema = z3.object({
-  title: z3.string().min(1),
-  severity: z3.enum(["high", "medium", "low"]).optional(),
-  location: z3.string().min(1).optional(),
-  summary: z3.string().min(1).optional()
-});
-var ReviewBlockedSchema = z3.object({
-  title: z3.string().min(1),
-  reason: z3.enum(["spec-deviation", "design-reversal"]),
-  why: z3.string().min(1).optional()
-});
-var ReviewRecordedEventSchema = BaseEventSchema.extend({
-  type: z3.literal("review_recorded"),
-  reviewer: z3.string().min(1),
-  target: z3.string().min(1),
-  repos: z3.array(z3.string().min(1)).optional(),
-  repos_resolved: z3.array(z3.string().min(1)).optional(),
-  commits: z3.array(z3.string().min(1)).optional(),
-  verdict: z3.enum(["pass", "needs-attention", "fail"]).optional(),
-  findings: z3.array(ReviewFindingSchema).optional(),
-  blocked: z3.array(ReviewBlockedSchema).optional()
-});
-var AdapterOutputEventSchema = BaseEventSchema.extend({
-  type: z3.literal("adapter_output"),
-  stream: z3.enum(["stdout", "stderr"]),
-  summary: z3.string(),
-  raw_ref: z3.string(),
-  redacted: z3.boolean().optional()
-}).strict();
-var EventSchema = z3.discriminatedUnion("type", [
-  SessionStartedEventSchema,
-  SessionEndedEventSchema,
-  SessionStatusChangedEventSchema,
-  ApprovalRequestedEventSchema,
-  ApprovalApprovedEventSchema,
-  ApprovalRejectedEventSchema,
-  ApprovalExpiredEventSchema,
-  CommandExecutedEventSchema,
-  GitSnapshotEventSchema,
-  FileChangedEventSchema,
-  DecisionRecordedEventSchema,
-  DecisionVoidedEventSchema,
-  TaskCreatedEventSchema,
-  TaskStatusChangedEventSchema,
-  TaskReconciledEventSchema,
-  TaskLinkageRefreshedEventSchema,
-  TaskDeletedEventSchema,
-  TaskArchivedEventSchema,
-  NoteAddedEventSchema,
-  ReviewRecordedEventSchema,
-  AdapterOutputEventSchema
-]);
-
-// src/events/event-replay.ts
 async function* replayEvents(sessionDir, options = {}) {
   const filePath = join2(sessionDir, "events.jsonl");
   try {
@@ -1815,6 +1873,9 @@ function processLine(rawLine, lineNo, options) {
     options.onWarning?.({ kind: "schema_violation", line: lineNo, cause: result.error });
     return null;
   }
+  if (hasRetiredZeroDuration(result.data)) {
+    options.onWarning?.({ kind: "retired_zero_duration", line: lineNo });
+  }
   return result.data;
 }
 async function readAllEvents(sessionDir, options = {}) {
@@ -2455,11 +2516,11 @@ var PRESET_JA = {
 
 // src/storage/sessions.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/events/chained-append.ts
-import { appendFile, readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { appendFile as appendFile2, readFile as readFile3 } from "fs/promises";
+import { join as join5 } from "path";
 
 // src/storage/lockfile.ts
 import { mkdir, readFile as readFile2, unlink as unlink2 } from "fs/promises";
@@ -2581,6 +2642,61 @@ function chainRawJsonLines(rawLines, sessionId) {
   return { lines, headHash: prev, count: lines.length };
 }
 
+// src/events/event-writer.ts
+import { appendFile } from "fs/promises";
+import { basename, join as join4 } from "path";
+async function appendEvent(sessionDir, event) {
+  let validated;
+  try {
+    validated = EventSchema.parse(event);
+  } catch (error) {
+    throw new Error("Invalid Basou event payload", { cause: error });
+  }
+  assertWritableEvent(validated);
+  const line = `${serializeEventLine(validated)}
+`;
+  try {
+    await appendFile(join4(sessionDir, "events.jsonl"), line, "utf8");
+  } catch (error) {
+    throw new Error("Failed to append event to events.jsonl", { cause: error });
+  }
+}
+async function writeEventsBulk(sessionDir, events, options = {}) {
+  const validated = [];
+  try {
+    for (const event of events) {
+      validated.push(EventSchema.parse(event));
+    }
+  } catch (error) {
+    throw new Error("Invalid Basou event payload", { cause: error });
+  }
+  for (const event of validated) assertWritableEvent(event);
+  const filePath = join4(sessionDir, "events.jsonl");
+  let body;
+  let result = null;
+  if (options.chain === true) {
+    const { lines, headHash, count } = chainEvents(validated, basename(sessionDir));
+    body = lines.length > 0 ? `${lines.join("\n")}
+` : "";
+    result = count > 0 ? { headHash, count } : null;
+  } else {
+    body = validated.length > 0 ? `${validated.map(serializeEventLine).join("\n")}
+` : "";
+  }
+  try {
+    await atomicReplace(filePath, body);
+  } catch (error) {
+    throw new Error("Failed to write events.jsonl", { cause: error });
+  }
+  return result;
+}
+function assertWritableEvent(event) {
+  if (!hasRetiredZeroDuration(event)) return;
+  throw new Error(
+    `Refusing to write command_executed with duration_ms: 0 at schema_version ${event.schema_version}: 0 is not a duration a command can have had, and writers at ${ZERO_DURATION_RETIRED_SINCE} and above record null`
+  );
+}
+
 // src/events/chained-append.ts
 function splitLinesBytes(buf) {
   const out = [];
@@ -2603,7 +2719,7 @@ function carriesPrevHash(line) {
   }
 }
 async function inspectChainTail(paths, sessionId) {
-  const filePath = join4(paths.sessions, sessionId, "events.jsonl");
+  const filePath = join5(paths.sessions, sessionId, "events.jsonl");
   let raw;
   try {
     raw = await readFile3(filePath);
@@ -2639,10 +2755,11 @@ async function appendChainedEventLocked(paths, sessionId, event) {
   } catch (error) {
     throw new Error("Invalid Basou event payload", { cause: error });
   }
+  assertWritableEvent(validated);
   const tail = await inspectChainTail(paths, sessionId);
   const line = tail.chained ? serializeEventLine({ ...validated, prev_hash: tail.head }) : serializeEventLine(validated);
   try {
-    await appendFile(join4(paths.sessions, sessionId, "events.jsonl"), `${line}
+    await appendFile2(join5(paths.sessions, sessionId, "events.jsonl"), `${line}
 `, "utf8");
   } catch (error) {
     throw new Error("Failed to append event to events.jsonl", { cause: error });
@@ -2754,7 +2871,7 @@ async function enumerateSessionDirs(paths) {
   }
 }
 async function readSessionYaml(paths, sessionId) {
-  const filePath = join5(paths.sessions, sessionId, "session.yaml");
+  const filePath = join6(paths.sessions, sessionId, "session.yaml");
   let raw;
   try {
     raw = await readYamlFile(filePath);
@@ -2778,7 +2895,7 @@ async function finalizeSessionYaml(paths, sessionId, mutate) {
       session.session.integrity = { head_hash: tail.head, event_count: tail.count };
     }
     const validated = SessionSchema.parse(session);
-    await overwriteYamlFile(join5(paths.sessions, sessionId, "session.yaml"), validated);
+    await overwriteYamlFile(join6(paths.sessions, sessionId, "session.yaml"), validated);
   } finally {
     await lock.release();
   }
@@ -2787,7 +2904,7 @@ async function classifySuspect(paths, sessionId, session, now, onWarning) {
   if (session.session.status !== "running") {
     return { suspect: false, suspectReason: null };
   }
-  const sessionDir = join5(paths.sessions, sessionId);
+  const sessionDir = join6(paths.sessions, sessionId);
   let endedFound = false;
   let lastEventOccurredAt = null;
   const replayOpts = onWarning !== void 0 ? { onWarning } : {};
@@ -2897,7 +3014,7 @@ async function renderDecisions(input) {
   const voids = /* @__PURE__ */ new Map();
   const knownEventIds = /* @__PURE__ */ new Set();
   for (const entry of entries) {
-    const sessionDir = join6(input.paths.sessions, entry.sessionId);
+    const sessionDir = join7(input.paths.sessions, entry.sessionId);
     try {
       for await (const ev of replayEvents(sessionDir, {
         onWarning: (w) => input.onWarning?.(w, entry.sessionId)
@@ -3024,53 +3141,6 @@ function shortDecisionSessionId(sessionId) {
   return sessionId.slice(0, 10);
 }
 
-// src/events/event-writer.ts
-import { appendFile as appendFile2 } from "fs/promises";
-import { basename, join as join7 } from "path";
-async function appendEvent(sessionDir, event) {
-  let validated;
-  try {
-    validated = EventSchema.parse(event);
-  } catch (error) {
-    throw new Error("Invalid Basou event payload", { cause: error });
-  }
-  const line = `${serializeEventLine(validated)}
-`;
-  try {
-    await appendFile2(join7(sessionDir, "events.jsonl"), line, "utf8");
-  } catch (error) {
-    throw new Error("Failed to append event to events.jsonl", { cause: error });
-  }
-}
-async function writeEventsBulk(sessionDir, events, options = {}) {
-  const validated = [];
-  try {
-    for (const event of events) {
-      validated.push(EventSchema.parse(event));
-    }
-  } catch (error) {
-    throw new Error("Invalid Basou event payload", { cause: error });
-  }
-  const filePath = join7(sessionDir, "events.jsonl");
-  let body;
-  let result = null;
-  if (options.chain === true) {
-    const { lines, headHash, count } = chainEvents(validated, basename(sessionDir));
-    body = lines.length > 0 ? `${lines.join("\n")}
-` : "";
-    result = count > 0 ? { headHash, count } : null;
-  } else {
-    body = validated.length > 0 ? `${validated.map(serializeEventLine).join("\n")}
-` : "";
-  }
-  try {
-    await atomicReplace(filePath, body);
-  } catch (error) {
-    throw new Error("Failed to write events.jsonl", { cause: error });
-  }
-  return result;
-}
-
 // src/events/verify.ts
 import { readFile as readFile4 } from "fs/promises";
 import { join as join8 } from "path";
@@ -3777,7 +3847,7 @@ async function createAdHocSessionWithEvent(input) {
       });
       const events = [
         {
-          schema_version: "0.1.0",
+          schema_version: EVENT_SCHEMA_VERSION,
           id: startedEventId,
           session_id: sessionId,
           occurred_at: input.occurredAt,
@@ -3785,7 +3855,7 @@ async function createAdHocSessionWithEvent(input) {
           type: "session_started"
         },
         {
-          schema_version: "0.1.0",
+          schema_version: EVENT_SCHEMA_VERSION,
           id: statusToRunningEventId,
           session_id: sessionId,
           occurred_at: input.occurredAt,
@@ -3796,7 +3866,7 @@ async function createAdHocSessionWithEvent(input) {
         },
         ...targetEvents,
         {
-          schema_version: "0.1.0",
+          schema_version: EVENT_SCHEMA_VERSION,
           id: statusToCompletedEventId,
           session_id: sessionId,
           occurred_at: input.occurredAt,
@@ -3806,7 +3876,7 @@ async function createAdHocSessionWithEvent(input) {
           to: "completed"
         },
         {
-          schema_version: "0.1.0",
+          schema_version: EVENT_SCHEMA_VERSION,
           id: endedEventId,
           session_id: sessionId,
           occurred_at: input.occurredAt,
@@ -4268,7 +4338,7 @@ var TaskWriteAfterEventError = class extends Error {
 };
 function buildTaskCreatedEvent(input) {
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: input.eventId,
     session_id: input.sessionId,
     occurred_at: input.occurredAt,
@@ -4280,7 +4350,7 @@ function buildTaskCreatedEvent(input) {
 }
 function buildTaskStatusChangedEvent(input) {
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: input.eventId,
     session_id: input.sessionId,
     occurred_at: input.occurredAt,
@@ -4313,7 +4383,7 @@ function buildAdHocArchiveLabel(title) {
 }
 function buildTaskReconciledEvent(input) {
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: input.eventId,
     session_id: input.sessionId,
     occurred_at: input.occurredAt,
@@ -4327,7 +4397,7 @@ function buildTaskReconciledEvent(input) {
 }
 function buildTaskDeletedEvent(input) {
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: input.eventId,
     session_id: input.sessionId,
     occurred_at: input.occurredAt,
@@ -4339,7 +4409,7 @@ function buildTaskDeletedEvent(input) {
 }
 function buildTaskArchivedEvent(input) {
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: input.eventId,
     session_id: input.sessionId,
     occurred_at: input.occurredAt,
@@ -4351,7 +4421,7 @@ function buildTaskArchivedEvent(input) {
 }
 function buildTaskLinkageRefreshedEvent(input) {
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: input.eventId,
     session_id: input.sessionId,
     occurred_at: input.occurredAt,
@@ -7169,9 +7239,13 @@ async function computeWorkStats(input) {
   for (const entry of entries) {
     const events = [];
     let eventsUnreadable = false;
+    let eventsLostLines = 0;
     try {
       for await (const ev of replayEvents(join16(input.paths.sessions, entry.sessionId), {
-        onWarning: (w) => input.onWarning?.(w, entry.sessionId)
+        onWarning: (w) => {
+          if (w.kind === "malformed_json" || w.kind === "schema_violation") eventsLostLines++;
+          input.onWarning?.(w, entry.sessionId);
+        }
       })) {
         events.push(ev);
       }
@@ -7187,7 +7261,8 @@ async function computeWorkStats(input) {
         entry.session.session,
         events,
         now,
-        eventsUnreadable
+        eventsUnreadable,
+        eventsLostLines
       )
     );
   }
@@ -7205,8 +7280,9 @@ async function computeWorkStats(input) {
     byDay: computeByDay(sessions, union.merged, timeZone)
   };
 }
-function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreadable = false) {
+function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreadable = false, eventsLostLines = 0) {
   let commandCount = 0;
+  let timedCommandCount = 0;
   let fileChangedCount = 0;
   let decisionCount = 0;
   let commandTimeMs = 0;
@@ -7216,7 +7292,11 @@ function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreada
     if (Number.isFinite(t)) timestamps.push(t);
     if (ev.type === "command_executed") {
       commandCount++;
-      commandTimeMs += ev.duration_ms;
+      const observed = readObservedDuration(ev);
+      if (observed !== null) {
+        timedCommandCount++;
+        commandTimeMs += observed;
+      }
     } else if (ev.type === "file_changed") {
       fileChangedCount++;
     } else if (ev.type === "decision_recorded") {
@@ -7249,7 +7329,26 @@ function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreada
     tokens,
     availability: {
       span: true,
-      commandTime: inner.source.kind !== "claude-code-import",
+      // Derived from what this session actually recorded, like its three
+      // siblings below. A source kind cannot answer this: the share of codex
+      // commands carrying an observed duration went from 1.5% (2026-05) to
+      // 56.0% (2026-08) as the vendor's log format changed, so the same kind
+      // is sometimes timed and sometimes not.
+      //
+      // Not `commandTimeMs > 0`: a sum cannot tell "no command was timed" from
+      // "no command ran", and the second case is the common one — 466 of one
+      // store's 862 sessions run no command at all (`basou note`,
+      // `decision capture`), and calling those unmeasured would poison the
+      // AND-aggregated workspace total forever.
+      //
+      // The two disjuncts need different backing. An observed duration is a
+      // fact about a command basou did see, and a line lost elsewhere in the
+      // stream does not take it away. "Ran no commands", by contrast, is a
+      // claim about the WHOLE stream, so it holds only if the whole stream was
+      // read: an unreadable events.jsonl, or one whose lines were dropped as
+      // malformed / schema-invalid, saw no commands because the log was lost,
+      // and 0ms then measures nothing.
+      commandTime: timedCommandCount > 0 || commandCount === 0 && !eventsUnreadable && eventsLostLines === 0,
       activeTime: active.intervals.length > 0,
       tokens: hasTokens(tokens),
       machineActive: machineActiveTimeMs > 0
@@ -8651,7 +8750,7 @@ function requireNonEmptyString(value, field) {
 function buildReviewRecordedEvent(input) {
   const { review } = input;
   return {
-    schema_version: "0.1.0",
+    schema_version: EVENT_SCHEMA_VERSION,
     id: input.eventId,
     session_id: input.sessionId,
     occurred_at: input.occurredAt,
@@ -8677,6 +8776,7 @@ function truncate(value) {
 
 // src/runtime/child-process-runner.ts
 import { spawn as spawn2 } from "child_process";
+import { performance } from "perf_hooks";
 var DEFAULT_KILL_GRACE_MS = 5e3;
 var ChildProcessRunner = class {
   async run(command, args, options) {
@@ -8691,6 +8791,7 @@ var ChildProcessRunner = class {
     const snapshotCwd = options.cwd;
     const captureMode = options.capture ?? "buffer";
     const started_at = /* @__PURE__ */ new Date();
+    const startedHrMs = performance.now();
     let child;
     try {
       child = spawn2(snapshotCommand, [...snapshotArgs], {
@@ -8777,7 +8878,7 @@ var ChildProcessRunner = class {
           stderr,
           started_at: started_at.toISOString(),
           ended_at: ended_at.toISOString(),
-          duration_ms: ended_at.getTime() - started_at.getTime(),
+          duration_ms: Math.round(performance.now() - startedHrMs),
           pid: child.pid ?? null
         });
       });
@@ -8841,15 +8942,28 @@ var SessionInnerImportSchema = z10.object({
   // imported. Mirrors the accept-and-discard of `prev_hash` on events.
   integrity: SessionIntegritySchema.optional()
 }).strict();
+var SESSION_IMPORT_SCHEMA_VERSION = "0.1.0";
 var SessionImportPayloadSchema = z10.object({
-  schema_version: z10.string(),
+  schema_version: z10.string().meta({
+    const: SESSION_IMPORT_SCHEMA_VERSION,
+    description: "Import envelope version. Must be exactly 0.1.0; any other value is rejected by the importer. This is the envelope's own version, not the version of the events it carries."
+  }),
   session: SessionInnerImportSchema,
   events: z10.array(EventSchema)
 }).strict();
 
 // src/schemas/json-schema.ts
-var JSON_SCHEMA_VERSION = "0.1.0";
-var ID_BASE = `https://basou.dev/schemas/${JSON_SCHEMA_VERSION}`;
+var JSON_SCHEMA_VERSIONS = {
+  manifest: "0.1.0",
+  session: "0.1.0",
+  event: EVENT_SCHEMA_VERSION,
+  task: "0.1.0",
+  approval: "0.1.0",
+  status: "0.1.0",
+  "task-index": "0.1.0",
+  "session-import": SESSION_IMPORT_SCHEMA_VERSION
+};
+var ID_BASE = "https://basou.dev/schemas";
 var JSON_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
 var DOCUMENTS = [
   {
@@ -8907,7 +9021,7 @@ function buildJsonSchemas() {
     const { $schema, ...rest } = generated;
     const schema = {
       $schema: typeof $schema === "string" ? $schema : JSON_SCHEMA_DIALECT,
-      $id: `${ID_BASE}/${doc.name}.schema.json`,
+      $id: `${ID_BASE}/${JSON_SCHEMA_VERSIONS[doc.name]}/${doc.name}.schema.json`,
       title: doc.title,
       description: doc.description,
       ...rest
@@ -9600,6 +9714,7 @@ export {
   ChildProcessRunner,
   DEFAULT_STOP_HOOK_MIN_EDITS,
   DecisionIdSchema,
+  EVENT_SCHEMA_VERSION,
   EventIdSchema,
   EventSchema,
   EventSourceSchema,
@@ -9608,7 +9723,7 @@ export {
   GENERATED_START,
   ID_PREFIXES,
   IsoTimestampSchema,
-  JSON_SCHEMA_VERSION,
+  JSON_SCHEMA_VERSIONS,
   ManifestSchema,
   ORIENTATION_END,
   ORIENTATION_START,
@@ -9616,6 +9731,7 @@ export {
   PROTOCOL_START,
   REVIEW_RECORD_NO_INPUT_HINT,
   RiskLevelSchema,
+  SESSION_IMPORT_SCHEMA_VERSION,
   SESSION_START_HOOK_CONTEXT_LIMIT,
   SESSION_START_HOOK_MATCHER,
   SESSION_START_HOOK_STATUS_MESSAGE,
@@ -9637,6 +9753,7 @@ export {
   TaskStatusSchema,
   TaskWriteAfterEventError,
   WorkspaceIdSchema,
+  ZERO_DURATION_RETIRED_SINCE,
   acquireLock,
   appendBasouGitignore,
   appendChainedEvent,
@@ -9683,6 +9800,7 @@ export {
   genesisHash,
   getDiff,
   getSnapshot,
+  hasRetiredZeroDuration,
   importSessionFromJson,
   inspectChainTail,
   instructionMode,
@@ -9716,6 +9834,7 @@ export {
   readAllEvents,
   readManifest,
   readMarkdownFile,
+  readObservedDuration,
   readSessionYaml,
   readStatus,
   readTaskFile,
@@ -9776,6 +9895,7 @@ export {
   writeEventsBulk,
   writeManifest,
   writeMarkdownFile,
+  writeObservedDuration,
   writeStatus,
   writeTaskFile,
   writeYamlFile