@basou/core 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -89,6 +89,9 @@ declare const ManifestSchema: z.ZodObject<{
             commit: "commit";
         }>>;
     }, z.core.$strip>;
+    import: z.ZodOptional<z.ZodObject<{
+        source_roots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /** Inferred runtime type for {@link ManifestSchema}. */
 type Manifest = z.infer<typeof ManifestSchema>;
@@ -101,10 +104,10 @@ declare const SessionInnerImportSchema: z.ZodObject<{
     source: z.ZodObject<{
         kind: z.ZodEnum<{
             "claude-code-adapter": "claude-code-adapter";
+            import: "import";
             "claude-code-import": "claude-code-import";
             "codex-import": "codex-import";
             human: "human";
-            import: "import";
             terminal: "terminal";
         }>;
         version: z.ZodLiteral<"0.1.0">;
@@ -143,6 +146,7 @@ declare const SessionInnerImportSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         active_gap_cap_ms: z.ZodOptional<z.ZodNumber>;
         active_time_method: z.ZodOptional<z.ZodString>;
+        machine_active_time_ms: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strict>;
 /**
@@ -160,10 +164,10 @@ declare const SessionImportPayloadSchema: z.ZodObject<{
         source: z.ZodObject<{
             kind: z.ZodEnum<{
                 "claude-code-adapter": "claude-code-adapter";
+                import: "import";
                 "claude-code-import": "claude-code-import";
                 "codex-import": "codex-import";
                 human: "human";
-                import: "import";
                 terminal: "terminal";
             }>;
             version: z.ZodLiteral<"0.1.0">;
@@ -202,6 +206,7 @@ declare const SessionImportPayloadSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             active_gap_cap_ms: z.ZodOptional<z.ZodNumber>;
             active_time_method: z.ZodOptional<z.ZodString>;
+            machine_active_time_ms: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strict>;
     events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -516,6 +521,13 @@ type CodexRolloutToPayloadOptions = {
  *   are parsed from the paired `function_call_output` (matched by `call_id`),
  *   whose text carries `Process exited with code N` and `Wall time: X seconds`.
  *
+ * Per-session `metrics` are also derived: token totals from the cumulative
+ * `token_count` events; active time from the real `task_started` ->
+ * `task_complete` turn spans (in-turn, uncapped) unioned with the gap-capped
+ * engagement series (between-turn bridging), labeled `turn-intervals`; and
+ * `machine_active_time_ms` from the summed `task_complete.duration_ms` (model
+ * compute time, a subset of active time).
+ *
  * Unlike the Claude importer this derives no `file_changed`: Codex has no
  * dedicated edit tool and applies edits inside `exec_command` (e.g.
  * `apply_patch`), so there is no clean file-change signal to map. Decisions
@@ -1262,10 +1274,10 @@ type SessionStatus = z.infer<typeof SessionStatusSchema>;
  */
 declare const SessionSourceKindSchema: z.ZodEnum<{
     "claude-code-adapter": "claude-code-adapter";
+    import: "import";
     "claude-code-import": "claude-code-import";
     "codex-import": "codex-import";
     human: "human";
-    import: "import";
     terminal: "terminal";
 }>;
 /** Inferred runtime type for {@link SessionSourceKindSchema}. */
@@ -1283,7 +1295,17 @@ type SessionSourceKind = z.infer<typeof SessionSourceKindSchema>;
  *   wall-clock ranges (so cross-session totals can de-duplicate overlapping
  *   work by interval union); `active_time_ms` is their summed duration;
  *   `active_gap_cap_ms` and `active_time_method` lock the methodology so the
- *   stored numbers stay interpretable if the method changes later.
+ *   stored numbers stay interpretable if the method changes later. When a
+ *   source records explicit per-turn intervals (Codex), `active_time_method` is
+ *   `turn-intervals` and the in-turn time is the log's real wall-clock span
+ *   rather than a gap-capped approximation; the active semantics are unchanged.
+ * - `machine_active_time_ms`: model compute time — the summed duration of the
+ *   source's per-turn spans (Codex `task_complete.duration_ms`), a SUBSET of a
+ *   single session's engaged active time. Unlike `active_intervals` it is a
+ *   plain sum, NOT wall-clock-deduplicated, so two concurrent sessions can sum
+ *   past their billable (union) active wall-clock — that is intended (two models
+ *   working at once did two machine-hours in one wall-clock hour). Captured only
+ *   for sources that record per-turn duration (Codex); absent otherwise.
  *
  * Absent on sessions imported before a given field existed (re-import to
  * backfill). Live sessions carry no engaged-time metrics and fall back to
@@ -1301,6 +1323,7 @@ declare const SessionMetricsSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     active_gap_cap_ms: z.ZodOptional<z.ZodNumber>;
     active_time_method: z.ZodOptional<z.ZodString>;
+    machine_active_time_ms: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /** Inferred runtime type for {@link SessionMetricsSchema}. */
 type SessionMetrics = z.infer<typeof SessionMetricsSchema>;
@@ -1319,10 +1342,10 @@ declare const SessionSchema: z.ZodObject<{
         source: z.ZodObject<{
             kind: z.ZodEnum<{
                 "claude-code-adapter": "claude-code-adapter";
+                import: "import";
                 "claude-code-import": "claude-code-import";
                 "codex-import": "codex-import";
                 human: "human";
-                import: "import";
                 terminal: "terminal";
             }>;
             version: z.ZodLiteral<"0.1.0">;
@@ -1361,6 +1384,7 @@ declare const SessionSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             active_gap_cap_ms: z.ZodOptional<z.ZodNumber>;
             active_time_method: z.ZodOptional<z.ZodString>;
+            machine_active_time_ms: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -2711,6 +2735,46 @@ declare class ChildProcessRunner implements ProcessRunner {
     run(command: string, args: readonly string[], options: RunOptions): Promise<RunResult>;
 }
 
+/**
+ * Schema version of the on-disk Basou v0.1 formats these JSON Schemas describe.
+ * It tracks {@link SchemaVersionSchema} (the `schema_version` field), NOT the
+ * npm package version, so the `$id` URLs stay stable while the package moves.
+ */
+declare const JSON_SCHEMA_VERSION = "0.1.0";
+/** One emitted JSON Schema artifact. */
+type JsonSchemaArtifact = {
+    /** Artifact basename without extension (e.g. `session`). */
+    name: string;
+    /** The JSON Schema document (draft 2020-12). */
+    schema: Record<string, unknown>;
+};
+/**
+ * Build the published JSON Schema artifacts from the canonical Zod schemas.
+ *
+ * Pure: no disk or environment access. Each artifact is `z.toJSONSchema` of the
+ * document schema, re-headed with a stable `$id` / `title` / `description` (the
+ * draft `$schema` from zod is preserved). This is the single generator used by
+ * both the `gen:schemas` script (which writes the committed files) and the
+ * drift-guard test (which asserts the committed files still match), so the two
+ * can never disagree.
+ *
+ * Generated in `io: "input"` mode so the artifacts describe what a consumer
+ * AUTHORS on disk, not zod's parsed output: a field with a `.default()` (e.g.
+ * `events_log`) stays optional rather than `required`, and a non-strict object
+ * omits `additionalProperties: false` so additive fields are allowed. Only the
+ * `.strict()` event variants (e.g. `adapter_output`) keep
+ * `additionalProperties: false`, preserving their reject-unknown contract.
+ *
+ * Note: prefixed-id fields carry a representable `pattern` (see
+ * `createPrefixedIdSchema`); other refinement-only constraints are not
+ * expressible in JSON Schema and are intentionally omitted.
+ */
+declare function buildJsonSchemas(): JsonSchemaArtifact[];
+/** Serialize an artifact's schema exactly as the committed file stores it
+ * (2-space indent, trailing newline) so the generator and the drift-guard test
+ * compare byte-for-byte. */
+declare function serializeJsonSchema(schema: Record<string, unknown>): string;
+
 /**
  * Schema version literal pinned to "0.1.0" for Basou v0.1.
  * Reused across every entity schema so inferred types narrow to the literal.
@@ -2823,6 +2887,8 @@ type MeasureAvailability = {
     activeTime: boolean;
     /** Token totals were captured (model-usage metrics present). */
     tokens: boolean;
+    /** Model compute time was captured (`machine_active_time_ms`; Codex only). */
+    machineActive: boolean;
 };
 /** Token rollup. Zero when not captured; `reasoning` is Codex-only. */
 type TokenTotals = {
@@ -2857,6 +2923,18 @@ type SessionWorkStats = {
      * (concurrent) work is not double-counted in billable totals.
      */
     activeIntervals: IsoInterval[];
+    /**
+     * Model compute time: the source's summed per-turn duration
+     * (`metrics.machine_active_time_ms`). A subset of `activeTimeMs`; 0 when the
+     * source records no per-turn duration (everything but Codex today).
+     */
+    machineActiveTimeMs: number;
+    /**
+     * Methodology lock copied from `metrics.active_time_method` (e.g.
+     * `turn-intervals` / `engaged-turns`); undefined when active time was derived
+     * from the event stream rather than stored metrics.
+     */
+    activeTimeMethod: string | undefined;
     commandCount: number;
     fileChangedCount: number;
     decisionCount: number;
@@ -2874,6 +2952,7 @@ type SourceWorkStats = {
     sessionSpanMs: number;
     commandTimeMs: number;
     activeTimeMs: number;
+    machineActiveTimeMs: number;
     commandCount: number;
     fileChangedCount: number;
     decisionCount: number;
@@ -2883,6 +2962,8 @@ type SourceWorkStats = {
     commandTimeReliable: boolean;
     /** At least one session of this kind captured token totals. */
     tokensAvailable: boolean;
+    /** At least one session of this kind captured model compute time. */
+    machineActiveAvailable: boolean;
 };
 type StatusCount = {
     status: SessionStatus;
@@ -2898,6 +2979,12 @@ type DayWorkStats = {
     /** Calendar date `YYYY-MM-DD` in the report timezone. */
     date: string;
     billableActiveTimeMs: number;
+    /**
+     * Model compute time for sessions started on this date (summed
+     * `machine_active_time_ms`). Not wall-clock-deduplicated, so — unlike
+     * `billableActiveTimeMs` — concurrent sessions sum freely.
+     */
+    machineActiveTimeMs: number;
     sessionCount: number;
     commandCount: number;
     fileChangedCount: number;
@@ -2917,6 +3004,13 @@ type WorkStatsTotals = {
      * `activeTimeMs` when no sessions overlap, and is smaller when they do.
      */
     billableActiveTimeMs: number;
+    /**
+     * Workspace-wide model compute time: summed `machine_active_time_ms`. A plain
+     * sum (not interval union), so it can exceed `billableActiveTimeMs` when
+     * sessions ran concurrently — two models working at once is two machine-hours
+     * in one wall-clock hour.
+     */
+    machineActiveTimeMs: number;
     commandCount: number;
     fileChangedCount: number;
     decisionCount: number;
@@ -2925,6 +3019,8 @@ type WorkStatsTotals = {
     /** No `claude-code-import` sessions present, so command time is workspace-wide real. */
     commandTimeReliable: boolean;
     tokensAvailable: boolean;
+    /** At least one session captured model compute time (`machine_active_time_ms`). */
+    machineActiveAvailable: boolean;
 };
 type WorkStatsResult = {
     generatedAt: string;
@@ -3053,6 +3149,14 @@ type CreateManifestInput = {
     now?: Date;
     /** Override for tests; defaults to a freshly generated `ws_<ULID>`. */
     workspaceId?: PrefixedId<"ws">;
+    /**
+     * Import source roots, each RELATIVE to the repository root (e.g. `"."`,
+     * `"../basou-workspace"`). Persisted under `import.source_roots` so
+     * `basou refresh` / `basou import` aggregate several sibling repos into one
+     * `.basou/`. Validated by `ManifestSchema` (absolute paths are rejected).
+     * Omitted from the manifest entirely when absent or empty.
+     */
+    sourceRoots?: string[];
 };
 /**
  * Build a fresh Manifest object that satisfies the manifest schema's
@@ -3303,4 +3407,4 @@ declare function overwriteYamlFile(filePath: string, value: unknown): Promise<vo
  */
 declare const BASOU_CORE_VERSION = "0.1.0";
 
-export { ACTIVE_GAP_CAP_MS, type ActiveTimeBasis, type AdapterOutputEvent, type AppendBasouGitignoreResult, type AppendEventToExistingInput, type AppendEventToExistingResult, type Approval, type ApprovalApprovedEvent, type ApprovalExpiredEvent, ApprovalIdSchema, type ApprovalLocation, type ApprovalRejectedEvent, type ApprovalRequestedEvent, ApprovalSchema, type ApprovalStatus, ApprovalStatusSchema, type ArchiveTaskInput, type ArchiveTaskResult, type AttachTaskInput, type AttachUpdateTaskStatusInput, type AttachableStatus, BASOU_CORE_VERSION, type BasouPaths, CLAUDE_IMPORT_SOURCE, CODEX_IMPORT_SOURCE, type CaptureMode, ChildProcessRunner, type ClaudeTranscriptRecord, type ClaudeTranscriptToPayloadOptions, type CodexRolloutRecord, type CodexRolloutToPayloadOptions, type CommandExecutedEvent, type CommandLookup, type CreateAdHocSessionInput, type CreateAdHocSessionResult, type CreateAdHocTaskInput, type CreateManifestInput, type CreateTaskInput, type CreateTaskResult, type DayWorkStats, DecisionIdSchema, type DecisionRecordedEvent, type DecisionsRendererInput, type DecisionsRendererResult, type DeleteTaskInput, type DeleteTaskResult, type DiffResult, type EditTaskInput, type EditTaskResult, type Event, EventIdSchema, EventSchema, EventSourceSchema, FailedToFinalizeError, type FileChange, type FileChangeStatus, type FileChangedEvent, GENERATED_END, GENERATED_START, type GitSnapshot, type GitSnapshotEvent, type HandoffRendererInput, type HandoffRendererResult, ID_PREFIXES, type IdPrefix, type ImportSessionOptions, type ImportSessionResult, IsoTimestampSchema, type LoadSessionEntriesOptions, type LoadTaskEntriesOptions, type LoadedApproval, type LockHandle, type LockScope, type Manifest, ManifestSchema, type MarkerSection, type MeasureAvailability, type NoteAddedEvent, type PrefixedId, type ProcessRunner, type ReconcileAllResult, type ReconcileAllTasksInput, type ReconcileAllTasksOptions, type ReconcileFailure, type ReconcileResult, type ReconcileTaskInput, type RefreshLinkageInput, type RefreshLinkageResult, type ReplayOptions, type ReplayWarning, type RiskLevel, RiskLevelSchema, type RunOptions, type RunResult, STUCK_THRESHOLD_MS, type SanitizePathOptions, type SanitizeRelatedFilesResult, SchemaVersionSchema, type Session, type SessionEndedEvent, type SessionEntry, SessionIdSchema, type SessionImportPayload, SessionImportPayloadSchema, type SessionInnerImportInput, SessionInnerImportSchema, type SessionMetrics, SessionMetricsSchema, SessionSchema, type SessionSkipReason, type SessionSourceKind, SessionSourceKindSchema, type SessionStartedEvent, type SessionStatus, type SessionStatusChangedEvent, SessionStatusSchema, type SessionWorkStats, type SourceWorkStats, type StatusCount, StatusSchema, type StatusSnapshot, type SuspectReason, type Task, type TaskArchivedEvent, type TaskCreatedEvent, type TaskDeletedEvent, type TaskDocument, TaskIdSchema, type TaskLinkageRefreshedEvent, type TaskReconciledEvent, TaskSchema, type TaskSkipReason, type TaskStatus, type TaskStatusChangedEvent, TaskStatusSchema, TaskWriteAfterEventError, type TaskWriteAfterEventPhase, type TokenTotals, type UpdateAdHocTaskStatusInput, type UpdateTaskStatusInput, type UpdateTaskStatusResult, type WorkStatsInput, type WorkStatsResult, type WorkStatsTotals, WorkspaceIdSchema, type WriteTaskFileMode, acquireLock, appendBasouGitignore, appendEvent, appendEventToExistingSession, archiveTask, assertBasouRootSafe, basouPaths, buildStatusSnapshot, classifySuspect, claudeCodeAdapterMetadata, claudeTranscriptToImportPayload, codexRolloutToImportPayload, computeWorkStats, createAdHocSessionWithEvent, createManifest, createTaskWithEvent, deleteTask, editTask, ensureBasouDirectory, enumerateApprovals, enumerateArchivedTaskIds, enumerateSessionDirs, enumerateTaskIds, findErrorCode, getDiff, getSnapshot, importSessionFromJson, isLazyExpired, isValidPrefixedId, linkYamlFile, loadApproval, loadSessionEntries, loadTaskEntries, overwriteYamlFile, parseDuration, parseMarkers, prefixedUlid, readAllEvents, readManifest, readMarkdownFile, readSessionYaml, readStatus, readTaskFile, readTaskFileWithArchiveFallback, readYamlFile, reconcileAllTasks, reconcileTask, refreshTaskLinkedSessions, renderDecisions, renderHandoff, renderWithMarkers, replayEvents, resolveClaudeCodeCommand, resolveRepositoryRoot, resolveSessionId, resolveTaskId, sanitizePath, sanitizeRelatedFiles, sanitizeWorkingDirectory, sessionWorkStatsFromEvents, summarizeAdapterOutput, tryRemoteUrl, ulid, updateTaskStatusWithEvent, writeEventsBulk, writeManifest, writeMarkdownFile, writeStatus, writeTaskFile, writeYamlFile };
+export { ACTIVE_GAP_CAP_MS, type ActiveTimeBasis, type AdapterOutputEvent, type AppendBasouGitignoreResult, type AppendEventToExistingInput, type AppendEventToExistingResult, type Approval, type ApprovalApprovedEvent, type ApprovalExpiredEvent, ApprovalIdSchema, type ApprovalLocation, type ApprovalRejectedEvent, type ApprovalRequestedEvent, ApprovalSchema, type ApprovalStatus, ApprovalStatusSchema, type ArchiveTaskInput, type ArchiveTaskResult, type AttachTaskInput, type AttachUpdateTaskStatusInput, type AttachableStatus, BASOU_CORE_VERSION, type BasouPaths, CLAUDE_IMPORT_SOURCE, CODEX_IMPORT_SOURCE, type CaptureMode, ChildProcessRunner, type ClaudeTranscriptRecord, type ClaudeTranscriptToPayloadOptions, type CodexRolloutRecord, type CodexRolloutToPayloadOptions, type CommandExecutedEvent, type CommandLookup, type CreateAdHocSessionInput, type CreateAdHocSessionResult, type CreateAdHocTaskInput, type CreateManifestInput, type CreateTaskInput, type CreateTaskResult, type DayWorkStats, DecisionIdSchema, type DecisionRecordedEvent, type DecisionsRendererInput, type DecisionsRendererResult, type DeleteTaskInput, type DeleteTaskResult, type DiffResult, type EditTaskInput, type EditTaskResult, type Event, EventIdSchema, EventSchema, EventSourceSchema, FailedToFinalizeError, type FileChange, type FileChangeStatus, type FileChangedEvent, GENERATED_END, GENERATED_START, type GitSnapshot, type GitSnapshotEvent, type HandoffRendererInput, type HandoffRendererResult, ID_PREFIXES, type IdPrefix, type ImportSessionOptions, type ImportSessionResult, IsoTimestampSchema, JSON_SCHEMA_VERSION, type JsonSchemaArtifact, type LoadSessionEntriesOptions, type LoadTaskEntriesOptions, type LoadedApproval, type LockHandle, type LockScope, type Manifest, ManifestSchema, type MarkerSection, type MeasureAvailability, type NoteAddedEvent, type PrefixedId, type ProcessRunner, type ReconcileAllResult, type ReconcileAllTasksInput, type ReconcileAllTasksOptions, type ReconcileFailure, type ReconcileResult, type ReconcileTaskInput, type RefreshLinkageInput, type RefreshLinkageResult, type ReplayOptions, type ReplayWarning, type RiskLevel, RiskLevelSchema, type RunOptions, type RunResult, STUCK_THRESHOLD_MS, type SanitizePathOptions, type SanitizeRelatedFilesResult, SchemaVersionSchema, type Session, type SessionEndedEvent, type SessionEntry, SessionIdSchema, type SessionImportPayload, SessionImportPayloadSchema, type SessionInnerImportInput, SessionInnerImportSchema, type SessionMetrics, SessionMetricsSchema, SessionSchema, type SessionSkipReason, type SessionSourceKind, SessionSourceKindSchema, type SessionStartedEvent, type SessionStatus, type SessionStatusChangedEvent, SessionStatusSchema, type SessionWorkStats, type SourceWorkStats, type StatusCount, StatusSchema, type StatusSnapshot, type SuspectReason, type Task, type TaskArchivedEvent, type TaskCreatedEvent, type TaskDeletedEvent, type TaskDocument, TaskIdSchema, type TaskLinkageRefreshedEvent, type TaskReconciledEvent, TaskSchema, type TaskSkipReason, type TaskStatus, type TaskStatusChangedEvent, TaskStatusSchema, TaskWriteAfterEventError, type TaskWriteAfterEventPhase, type TokenTotals, type UpdateAdHocTaskStatusInput, type UpdateTaskStatusInput, type UpdateTaskStatusResult, type WorkStatsInput, type WorkStatsResult, type WorkStatsTotals, WorkspaceIdSchema, type WriteTaskFileMode, acquireLock, appendBasouGitignore, appendEvent, appendEventToExistingSession, archiveTask, assertBasouRootSafe, basouPaths, buildJsonSchemas, buildStatusSnapshot, classifySuspect, claudeCodeAdapterMetadata, claudeTranscriptToImportPayload, codexRolloutToImportPayload, computeWorkStats, createAdHocSessionWithEvent, createManifest, createTaskWithEvent, deleteTask, editTask, ensureBasouDirectory, enumerateApprovals, enumerateArchivedTaskIds, enumerateSessionDirs, enumerateTaskIds, findErrorCode, getDiff, getSnapshot, importSessionFromJson, isLazyExpired, isValidPrefixedId, linkYamlFile, loadApproval, loadSessionEntries, loadTaskEntries, overwriteYamlFile, parseDuration, parseMarkers, prefixedUlid, readAllEvents, readManifest, readMarkdownFile, readSessionYaml, readStatus, readTaskFile, readTaskFileWithArchiveFallback, readYamlFile, reconcileAllTasks, reconcileTask, refreshTaskLinkedSessions, renderDecisions, renderHandoff, renderWithMarkers, replayEvents, resolveClaudeCodeCommand, resolveRepositoryRoot, resolveSessionId, resolveTaskId, sanitizePath, sanitizeRelatedFiles, sanitizeWorkingDirectory, serializeJsonSchema, sessionWorkStatsFromEvents, summarizeAdapterOutput, tryRemoteUrl, ulid, updateTaskStatusWithEvent, writeEventsBulk, writeManifest, writeMarkdownFile, writeStatus, writeTaskFile, writeYamlFile };

package/dist/index.js

@@ -49,6 +49,7 @@ function isValidPrefixedId(value) {
 // src/stats/active-time.ts
 var ACTIVE_GAP_CAP_MS = 5 * 60 * 1e3;
 var ENGAGED_TURNS_METHOD = "engaged-turns";
+var TURN_INTERVALS_METHOD = "turn-intervals";
 function activeTimeFromTimestamps(timestampsMs, capMs) {
   const sorted = timestampsMs.filter((t) => Number.isFinite(t)).sort((a, b) => a - b);
   const raw = [];
@@ -340,6 +341,7 @@ var CODEX_IMPORT_SOURCE = "codex-import";
 function codexRolloutToImportPayload(records, options) {
   const placeholderSessionId = prefixedUlid("ses");
   const outputsByCallId = indexOutputs(records);
+  const turnStartMsByTurnId = indexTaskStarts(records);
   const derived = [];
   let minTs;
   let maxTs;
@@ -347,6 +349,8 @@ function codexRolloutToImportPayload(records, options) {
   let codexSessionId;
   let lastTokenTotals;
   const engagementTsMs = [];
+  const completions = [];
+  const completedTurnIds = /* @__PURE__ */ new Set();
   for (const record of records) {
     const ts = readString2(record.timestamp);
     if (ts === void 0) continue;
@@ -371,6 +375,16 @@ function codexRolloutToImportPayload(records, options) {
         const tsMs = Date.parse(ts);
         if (Number.isFinite(tsMs)) engagementTsMs.push(tsMs);
       }
+      if (pt === "task_complete") {
+        const turnId = readString2(payload2.turn_id);
+        if (turnId === void 0 || !completedTurnIds.has(turnId)) {
+          if (turnId !== void 0) completedTurnIds.add(turnId);
+          completions.push({
+            interval: turnIntervalFromComplete(ts, payload2, turnStartMsByTurnId),
+            durationMs: readNonNegInt2(payload2.duration_ms)
+          });
+        }
+      }
       continue;
     }
     if (readString2(record.type) !== "response_item") continue;
@@ -401,7 +415,23 @@ function codexRolloutToImportPayload(records, options) {
   const commandCount = derived.length;
   const date = minTs.slice(0, 10);
   const label = `codex ${date}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}`;
-  const active = engagementTsMs.length >= 2 ? activeTimeFromTimestamps(engagementTsMs, ACTIVE_GAP_CAP_MS) : void 0;
+  const minTsMs = Date.parse(minTs);
+  const turnIntervals = [];
+  let machineActiveMs = 0;
+  let allCompletedTurnsHaveDuration = true;
+  for (const { interval, durationMs } of completions) {
+    if (durationMs <= 0) allCompletedTurnsHaveDuration = false;
+    if (interval === void 0) continue;
+    const start = Number.isFinite(minTsMs) ? Math.max(interval[0], minTsMs) : interval[0];
+    const end = interval[1];
+    if (!(start < end)) continue;
+    turnIntervals.push([start, end]);
+    machineActiveMs += Math.min(durationMs, end - start);
+  }
+  const pointResult = activeTimeFromTimestamps(engagementTsMs, ACTIVE_GAP_CAP_MS);
+  const active = turnIntervals.length > 0 || pointResult.intervals.length > 0 ? unionDurationMs([...turnIntervals, ...pointResult.intervals]) : void 0;
+  const activeMethod = turnIntervals.length > 0 ? TURN_INTERVALS_METHOD : ENGAGED_TURNS_METHOD;
+  const machineActive = allCompletedTurnsHaveDuration ? machineActiveMs : 0;
   const tokenFields = lastTokenTotals === void 0 ? {} : {
     ...readNonNegInt2(lastTokenTotals.output_tokens) > 0 ? { output_tokens: readNonNegInt2(lastTokenTotals.output_tokens) } : {},
     ...readNonNegInt2(lastTokenTotals.input_tokens) > 0 ? { input_tokens: readNonNegInt2(lastTokenTotals.input_tokens) } : {},
@@ -412,10 +442,11 @@ function codexRolloutToImportPayload(records, options) {
     ...tokenFields,
     ...active !== void 0 && active.ms > 0 ? {
       active_time_ms: active.ms,
-      active_intervals: intervalsMsToIso(active.intervals),
+      active_intervals: intervalsMsToIso(active.merged),
       active_gap_cap_ms: ACTIVE_GAP_CAP_MS,
-      active_time_method: ENGAGED_TURNS_METHOD
-    } : {}
+      active_time_method: activeMethod
+    } : {},
+    ...machineActive > 0 ? { machine_active_time_ms: machineActive } : {}
   };
   const metrics = Object.keys(metricsFields).length > 0 ? metricsFields : void 0;
   const payload = {
@@ -496,6 +527,30 @@ function readCallId(value, outputs) {
   const callId = readString2(value);
   return callId !== void 0 ? outputs.get(callId) : void 0;
 }
+function turnIntervalFromComplete(endTs, payload, startMsByTurnId) {
+  const endMs = Date.parse(endTs);
+  if (!Number.isFinite(endMs)) return void 0;
+  const turnId = readString2(payload.turn_id);
+  const indexedStart = turnId !== void 0 ? startMsByTurnId.get(turnId) : void 0;
+  const durationMs = readNonNegInt2(payload.duration_ms);
+  const startMs = indexedStart !== void 0 ? indexedStart : durationMs > 0 ? endMs - durationMs : void 0;
+  if (startMs === void 0 || !(startMs < endMs)) return void 0;
+  return [startMs, endMs];
+}
+function indexTaskStarts(records) {
+  const byTurnId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (readString2(record.type) !== "event_msg") continue;
+    const payload = isObject2(record.payload) ? record.payload : void 0;
+    if (payload === void 0 || readString2(payload.type) !== "task_started") continue;
+    const turnId = readString2(payload.turn_id);
+    const startMs = Date.parse(readString2(record.timestamp) ?? "");
+    if (turnId !== void 0 && Number.isFinite(startMs) && !byTurnId.has(turnId)) {
+      byTurnId.set(turnId, startMs);
+    }
+  }
+  return byTurnId;
+}
 function parseExitCode(output) {
   if (output === void 0) return null;
   const match = output.match(/Process exited with code (-?\d+)/);
@@ -546,7 +601,10 @@ var SchemaVersionSchema = 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>` });
+  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");
@@ -991,7 +1049,8 @@ var SessionMetricsSchema = z4.object({
   active_time_ms: z4.number().int().nonnegative().optional(),
   active_intervals: z4.array(z4.object({ start: IsoTimestampSchema, end: IsoTimestampSchema })).optional(),
   active_gap_cap_ms: z4.number().int().nonnegative().optional(),
-  active_time_method: z4.string().optional()
+  active_time_method: z4.string().optional(),
+  machine_active_time_ms: z4.number().int().nonnegative().optional()
 });
 var SessionInnerSchema = z4.object({
   id: SessionIdSchema,
@@ -3799,6 +3858,9 @@ function classifySpawnError(error) {
   return new Error("Failed to spawn child process", { cause: error });
 }
 
+// src/schemas/json-schema.ts
+import { z as z11 } from "zod";
+
 // src/schemas/manifest.schema.ts
 import { z as z9 } from "zod";
 var ProjectSchema = z9.object({
@@ -3823,6 +3885,13 @@ var AdaptersSchema = z9.object({
 var GitConfigSchema = z9.object({
   events_log: z9.enum(["ignore", "commit"]).default("ignore")
 });
+var SOURCE_ROOT_PATTERN = /^(?![~/\\])(?![A-Za-z]:)[^\0\\]+$/;
+var SourceRootSchema = z9.string().min(1).regex(SOURCE_ROOT_PATTERN, {
+  message: "source_roots entries must be relative paths (no absolute path, '~', '\\', or null byte)"
+});
+var ImportConfigSchema = z9.object({
+  source_roots: z9.array(SourceRootSchema).min(1).optional()
+});
 var WorkspaceMetaSchema = z9.object({
   id: WorkspaceIdSchema,
   name: z9.string().min(1),
@@ -3837,7 +3906,8 @@ var ManifestSchema = z9.object({
   capabilities: CapabilitiesSchema,
   approval: ApprovalConfigSchema,
   adapters: AdaptersSchema,
-  git: GitConfigSchema
+  git: GitConfigSchema,
+  import: ImportConfigSchema.optional()
 });
 
 // src/schemas/session-import.schema.ts
@@ -3874,6 +3944,79 @@ var SessionImportPayloadSchema = z10.object({
   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_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+var DOCUMENTS = [
+  {
+    name: "manifest",
+    schema: ManifestSchema,
+    title: "Basou Manifest",
+    description: "The `.basou/manifest.yaml` workspace manifest."
+  },
+  {
+    name: "session",
+    schema: SessionSchema,
+    title: "Basou Session",
+    description: "A `.basou/sessions/<id>/session.yaml` session record."
+  },
+  {
+    name: "event",
+    schema: EventSchema,
+    title: "Basou Event",
+    description: "One line of a `.basou/sessions/<id>/events.jsonl` stream (a discriminated union over the event `type`)."
+  },
+  {
+    name: "task",
+    schema: TaskSchema,
+    title: "Basou Task",
+    description: "The YAML front matter of a `.basou/tasks/<id>.md` task document."
+  },
+  {
+    name: "approval",
+    schema: ApprovalSchema,
+    title: "Basou Approval",
+    description: "A `.basou/approvals/{pending,resolved}/<id>.yaml` approval record."
+  },
+  {
+    name: "status",
+    schema: StatusSchema,
+    title: "Basou Status",
+    description: "The `.basou/status.json` workspace status snapshot."
+  },
+  {
+    name: "task-index",
+    schema: TaskIndexSchema,
+    title: "Basou Task Index",
+    description: "The `.basou/tasks/index.json` task lookup index."
+  },
+  {
+    name: "session-import",
+    schema: SessionImportPayloadSchema,
+    title: "Basou Session Import Payload",
+    description: "The portable session payload consumed by `basou session import`."
+  }
+];
+function buildJsonSchemas() {
+  return DOCUMENTS.map((doc) => {
+    const generated = z11.toJSONSchema(doc.schema, { io: "input" });
+    const { $schema, ...rest } = generated;
+    const schema = {
+      $schema: typeof $schema === "string" ? $schema : JSON_SCHEMA_DIALECT,
+      $id: `${ID_BASE}/${doc.name}.schema.json`,
+      title: doc.title,
+      description: doc.description,
+      ...rest
+    };
+    return { name: doc.name, schema };
+  });
+}
+function serializeJsonSchema(schema) {
+  return `${JSON.stringify(schema, null, 2)}
+`;
+}
+
 // src/stats/work-stats.ts
 import { join as join11 } from "path";
 function resolveTimeZone(timeZone) {
@@ -3962,6 +4105,7 @@ function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreada
   const span = computeSpan(inner.started_at, inner.ended_at, now);
   const tokens = readTokens(inner.metrics);
   const active = resolveActiveTime(inner.metrics, timestamps);
+  const machineActiveTimeMs = inner.metrics?.machine_active_time_ms ?? 0;
   return {
     sessionId,
     label: inner.label,
@@ -3975,6 +4119,8 @@ function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreada
     activeTimeMs: active.ms,
     activeTimeBasis: active.basis,
     activeIntervals: intervalsMsToIso(active.intervals),
+    machineActiveTimeMs,
+    activeTimeMethod: inner.metrics?.active_time_method,
     commandCount,
     fileChangedCount,
     decisionCount,
@@ -3984,7 +4130,8 @@ function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreada
       span: true,
       commandTime: inner.source.kind !== "claude-code-import",
       activeTime: active.intervals.length > 0,
-      tokens: hasTokens(tokens)
+      tokens: hasTokens(tokens),
+      machineActive: machineActiveTimeMs > 0
     },
     spanClamped: span.clamped,
     eventsUnreadable
@@ -4036,19 +4183,22 @@ function computeTotals(sessions, billableActiveTimeMs) {
     commandTimeMs: 0,
     activeTimeMs: 0,
     billableActiveTimeMs,
+    machineActiveTimeMs: 0,
     commandCount: 0,
     fileChangedCount: 0,
     decisionCount: 0,
     eventCount: 0,
     tokens,
     commandTimeReliable: true,
-    tokensAvailable: false
+    tokensAvailable: false,
+    machineActiveAvailable: false
   };
   for (const s of sessions) {
     if (s.open) totals.openSessionCount++;
     totals.sessionSpanMs += s.sessionSpanMs;
     totals.commandTimeMs += s.commandTimeMs;
     totals.activeTimeMs += s.activeTimeMs;
+    totals.machineActiveTimeMs += s.machineActiveTimeMs;
     totals.commandCount += s.commandCount;
     totals.fileChangedCount += s.fileChangedCount;
     totals.decisionCount += s.decisionCount;
@@ -4056,6 +4206,7 @@ function computeTotals(sessions, billableActiveTimeMs) {
     addTokens(tokens, s.tokens);
     if (!s.availability.commandTime) totals.commandTimeReliable = false;
     if (s.availability.tokens) totals.tokensAvailable = true;
+    if (s.availability.machineActive) totals.machineActiveAvailable = true;
   }
   return totals;
 }
@@ -4070,13 +4221,15 @@ function computeBySource(sessions) {
         sessionSpanMs: 0,
         commandTimeMs: 0,
         activeTimeMs: 0,
+        machineActiveTimeMs: 0,
         commandCount: 0,
         fileChangedCount: 0,
         decisionCount: 0,
         eventCount: 0,
         tokens: emptyTokens(),
         commandTimeReliable: true,
-        tokensAvailable: false
+        tokensAvailable: false,
+        machineActiveAvailable: false
       };
       map.set(s.sourceKind, row);
     }
@@ -4084,6 +4237,7 @@ function computeBySource(sessions) {
     row.sessionSpanMs += s.sessionSpanMs;
     row.commandTimeMs += s.commandTimeMs;
     row.activeTimeMs += s.activeTimeMs;
+    row.machineActiveTimeMs += s.machineActiveTimeMs;
     row.commandCount += s.commandCount;
     row.fileChangedCount += s.fileChangedCount;
     row.decisionCount += s.decisionCount;
@@ -4091,6 +4245,7 @@ function computeBySource(sessions) {
     addTokens(row.tokens, s.tokens);
     if (!s.availability.commandTime) row.commandTimeReliable = false;
     if (s.availability.tokens) row.tokensAvailable = true;
+    if (s.availability.machineActive) row.machineActiveAvailable = true;
   }
   return [...map.values()].sort((a, b) => a.sourceKind.localeCompare(b.sourceKind));
 }
@@ -4112,6 +4267,7 @@ function computeByDay(sessions, unionMerged, timeZone) {
       day = {
         date,
         billableActiveTimeMs: 0,
+        machineActiveTimeMs: 0,
         sessionCount: 0,
         commandCount: 0,
         fileChangedCount: 0,
@@ -4130,6 +4286,7 @@ function computeByDay(sessions, unionMerged, timeZone) {
     if (!Number.isFinite(startedMs)) continue;
     const day = ensure(tzDate(startedMs, timeZone));
     day.sessionCount++;
+    day.machineActiveTimeMs += s.machineActiveTimeMs;
     day.commandCount += s.commandCount;
     day.fileChangedCount += s.fileChangedCount;
     day.decisionCount += s.decisionCount;
@@ -4305,7 +4462,8 @@ function createManifest(input) {
     adapters: {
       "claude-code": { enabled: true }
     },
-    git: { events_log: "ignore" }
+    git: { events_log: "ignore" },
+    ...input.sourceRoots !== void 0 && input.sourceRoots.length > 0 ? { import: { source_roots: input.sourceRoots } } : {}
   };
   return ManifestSchema.parse(manifest);
 }
@@ -4594,6 +4752,7 @@ export {
   GENERATED_START,
   ID_PREFIXES,
   IsoTimestampSchema,
+  JSON_SCHEMA_VERSION,
   ManifestSchema,
   RiskLevelSchema,
   STUCK_THRESHOLD_MS,
@@ -4618,6 +4777,7 @@ export {
   archiveTask,
   assertBasouRootSafe,
   basouPaths,
+  buildJsonSchemas,
   buildStatusSnapshot,
   classifySuspect,
   claudeCodeAdapterMetadata,
@@ -4670,6 +4830,7 @@ export {
   sanitizePath,
   sanitizeRelatedFiles,
   sanitizeWorkingDirectory,
+  serializeJsonSchema,
   sessionWorkStatsFromEvents,
   summarizeAdapterOutput,
   tryRemoteUrl,