@juli-os/ledger 0.0.0-stage → 0.1.1

package/dist/platform/ledger/casefile.d.ts

@@ -0,0 +1,47 @@
+import type { JsonValue } from '../shared/json.ts';
+export interface CaseDecision {
+    readonly seq: number;
+    readonly action: string;
+    readonly by: string;
+    readonly note: string;
+    readonly at: string;
+}
+export interface ArtifactRef {
+    readonly id: string;
+    readonly name: string;
+    readonly role: string;
+    readonly key: string;
+    readonly seq: number;
+    readonly sha8: string;
+    readonly bytes: number;
+}
+export interface CaseFileDoc {
+    readonly original: Readonly<Record<string, string>>;
+    readonly extract: JsonValue | null;
+    readonly executions: readonly JsonValue[];
+    readonly draft: JsonValue | null;
+    readonly decisions: readonly CaseDecision[];
+    readonly references: readonly string[];
+    readonly artifacts: readonly ArtifactRef[];
+    readonly updatedAt: string;
+}
+export declare const emptyCaseFile: (now: Date) => CaseFileDoc;
+export declare const parseCaseFile: (raw: string | null, now: Date) => CaseFileDoc;
+export declare const serializeCaseFile: (cf: CaseFileDoc) => string;
+export declare const withOriginal: (cf: CaseFileDoc, o: {
+    from: string;
+    fromName?: string;
+    subject: string;
+    body: string;
+    messageId: string;
+}, now: Date) => CaseFileDoc;
+export declare const appendSection: (cf: CaseFileDoc, section: "extract" | "draft", value: JsonValue, now: Date) => CaseFileDoc;
+export declare const appendExecution: (cf: CaseFileDoc, execution: JsonValue, now: Date) => CaseFileDoc;
+export declare const appendDecision: (cf: CaseFileDoc, d: Omit<CaseDecision, "at">, now: Date) => CaseFileDoc;
+export declare const appendReference: (cf: CaseFileDoc, messageId: string, now: Date) => CaseFileDoc;
+export declare const originalEmail: (cf: CaseFileDoc) => {
+    from: string;
+    subject: string;
+    body: string;
+    messageId: string;
+};

package/dist/platform/ledger/pricing.d.ts

@@ -0,0 +1,57 @@
+export interface TierWhen {
+    readonly inputLt?: number;
+    readonly inputGte?: number;
+    readonly outputLt?: number;
+    readonly outputGte?: number;
+}
+export interface PriceTier {
+    readonly when: TierWhen;
+    readonly input: number;
+    readonly cache: number | null;
+    readonly output: number;
+    readonly note: string;
+}
+export interface ModelPrice {
+    readonly id: string;
+    readonly label: string;
+    readonly tiers: readonly PriceTier[];
+}
+export declare const PRICING_SOURCE = "https://docs.bigmodel.cn/cn/guide/start/pricing";
+export declare const PRICING_RETRIEVED_AT = "2026-10-06";
+export declare const BIGMODEL_PRICES: readonly ModelPrice[];
+export interface UsageRow {
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cachedTokens: number;
+}
+export interface CostBreakdown {
+    readonly cache: number;
+    readonly input: number;
+    readonly output: number;
+    readonly total: number;
+}
+export interface ModelUsageCost {
+    readonly model: string;
+    readonly label: string;
+    readonly free: boolean;
+    readonly priced: boolean;
+    readonly calls: number;
+    readonly inputTokens: number;
+    readonly cachedTokens: number;
+    readonly inputTokensChargeable: number;
+    readonly outputTokens: number;
+    readonly tiersHit: readonly string[];
+    readonly costCny: CostBreakdown;
+}
+export interface UsageCost {
+    readonly currency: 'CNY';
+    readonly unit: 'per_1m_tokens';
+    readonly pricingSource: string;
+    readonly pricingRetrievedAt: string;
+    readonly byModel: readonly ModelUsageCost[];
+    readonly totalCny: CostBreakdown;
+    readonly unpricedModels: readonly string[];
+}
+export declare const findPrice: (model: string) => ModelPrice | null;
+export declare const priceUsage: (rows: readonly UsageRow[]) => UsageCost;

package/dist/platform/ledger/store.d.ts

@@ -0,0 +1,98 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { JsonRecord, JsonValue } from '../shared/json.ts';
+import { type Clock, type IdGen } from '../shared/clock.ts';
+import type { LedgerEvent, Prompt, Run, Step, StepKind, StepStatus, TaskView, Workflow, WorkflowStatus } from '../../contracts/entities.ts';
+import { type CaseFileDoc } from './casefile.ts';
+export interface LifecycleStore {
+    readonly db: DatabaseSync;
+    createWorkflow(w: {
+        kind: string;
+        title: string;
+        meta?: JsonRecord;
+        parentId?: string;
+        status?: WorkflowStatus;
+        owner?: string;
+    }): Workflow;
+    getWorkflow(id: string): Workflow | null;
+    listWorkflows(limit?: number, status?: string): readonly Workflow[];
+    setWorkflowStatus(id: string, status: WorkflowStatus): void;
+    setWorkflowSession(id: string, session: string): void;
+    updateWorkflowMeta(id: string, patch: JsonRecord): JsonRecord;
+    setWorkflowRouting(id: string, session: string, project: string): void;
+    assignThread(workflowId: string, threadId: string): void;
+    latestByMessageId(messageId: string, excludeWorkflowId?: string): Workflow | null;
+    recentBySender(from: string, sinceIso: string, excludeWorkflowId?: string, limit?: number): readonly Workflow[];
+    loadCaseFile(id: string): CaseFileDoc;
+    saveCaseFile(id: string, cf: CaseFileDoc): void;
+    createStep(s: {
+        workflowId: string;
+        seq: number;
+        kind: StepKind;
+        title: string;
+        input?: JsonRecord;
+    }): Step;
+    insertStepsAt(workflowId: string, afterSeq: number, steps: readonly {
+        kind: StepKind;
+        title: string;
+        input?: JsonRecord;
+    }[]): void;
+    getStep(id: string): Step | null;
+    stepsForWorkflow(id: string): readonly Step[];
+    currentStep(id: string): Step | null;
+    setStepStatus(id: string, status: StepStatus): void;
+    setStepInput(id: string, patch: JsonRecord): void;
+    insertRelay(r: {
+        workflowId: string;
+        stepId: string;
+        session: string;
+        text: string;
+        marker: string;
+    }): string;
+    pendingRelays(): readonly {
+        id: string;
+        workflowId: string;
+        stepId: string;
+        session: string;
+        text: string;
+        marker: string;
+        createdAt: string;
+        attempts: number;
+        lastError: string;
+    }[];
+    markRelayDelivered(id: string): void;
+    markRelayAttempt(id: string, error: string): void;
+    setStepOutput(id: string, patch: JsonRecord): void;
+    appendStepOutputItem(id: string, key: string, entry: JsonValue, cap: number): void;
+    claimRunningStep(id: string): boolean;
+    listSteps(status: StepStatus, limit?: number): readonly Step[];
+    runningAgentStepForSession(session: string): Step | null;
+    sessionHasOpenWork(session: string, excludeWorkflowId?: string): boolean;
+    appendEvent(entityType: 'workflow' | 'step' | 'judgment' | 'agent', entityId: string, type: string, payload?: JsonRecord): LedgerEvent;
+    listEvents(limit?: number, types?: readonly string[]): readonly LedgerEvent[];
+    eventsSince(afterId: number, limit?: number): readonly LedgerEvent[];
+    entityEvents(entityType: LedgerEvent['entityType'], entityId: string, type: string, limit?: number): readonly LedgerEvent[];
+    lastEventAt(entityType: LedgerEvent['entityType'], entityId: string): string;
+    createRun(workflowId: string, session: string): Run;
+    hasActiveDedup(key: string): boolean;
+    hasSeenDedup(key: string): boolean;
+    sentMessageIdExists(messageId: string): boolean;
+    recordSentMessageId(messageId: string, meta?: {
+        to?: string;
+        subject?: string;
+    }): void;
+    activeRunForSession(session: string): Run | null;
+    createPrompt(runId: string, content: string, source: string): Prompt;
+    latestPromptForSession(session: string, statuses: readonly Prompt['status'][]): Prompt | null;
+    prune(retentionDays: number): {
+        events: number;
+        workflows: number;
+    };
+    taskViews(limit?: number): {
+        readonly views: readonly TaskView[];
+        readonly map: Readonly<Record<string, string>>;
+    };
+}
+export declare const createLedgerStore: (dbPath: string, deps?: {
+    readonly clock?: Clock;
+    readonly ids?: IdGen;
+}) => LifecycleStore;

package/dist/platform/ledger/usage.d.ts

@@ -0,0 +1,72 @@
+import { type UsageCost } from './pricing.ts';
+export interface UsageRecord {
+    readonly id: number;
+    readonly source: string;
+    readonly note: string;
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cachedTokens: number;
+    readonly durationMs: number;
+    readonly error: string;
+    readonly createdAt: string;
+}
+export interface UsageStats {
+    readonly totalCalls: number;
+    readonly totalInputTokens: number;
+    readonly totalOutputTokens: number;
+    readonly byModel: readonly {
+        readonly model: string;
+        readonly calls: number;
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+    }[];
+}
+export interface TimelinePoint {
+    readonly hour: string;
+    readonly calls: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+export interface UsageStore {
+    record(r: {
+        source: string;
+        note?: string;
+        model?: string;
+        inputTokens?: number;
+        outputTokens?: number;
+        cachedTokens?: number;
+        durationMs?: number;
+        error?: string;
+    }): void;
+    stats(sinceHours?: number): UsageStats;
+    timeline(hours?: number): readonly TimelinePoint[];
+    byLocalDay(days?: number): readonly {
+        readonly day: string;
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+        readonly cachedTokens: number;
+        readonly calls: number;
+    }[];
+    perSessionWindows(tmuxSession: string, windows: readonly (readonly [string, string])[]): {
+        count: number;
+        inputTokens: number;
+        outputTokens: number;
+    };
+    perSessionWindowsRows(tmuxSession: string, windows: readonly (readonly [string, string])[]): readonly {
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        cachedTokens: number;
+    }[];
+    sessionWindowsPriced(sessions: readonly string[], windows: readonly (readonly [string, string])[]): UsageCost;
+    latestInputTokens(tmuxSession: string): number;
+    lastClaudeCodeAt(tmuxSession: string): string;
+    recent(limit?: number): readonly UsageRecord[];
+    recordClaudeSession(claudeSessionId: string, tmuxSession: string, transcriptPath: string, cwd: string): void;
+    recordClaudeSessionPrecise(claudeSessionId: string, tmuxSession: string): void;
+    ingestProjectTranscripts(claudeProjectsDir: string): number;
+    needsClaudeReplay(): boolean;
+    resetClaudeIngest(): void;
+}
+export declare const createUsageStore: (dbPath: string, now?: () => Date) => UsageStore;

package/dist/platform/shared/clock.d.ts

@@ -0,0 +1,9 @@
+export interface Clock {
+    now(): Date;
+}
+export declare const systemClock: Clock;
+export interface IdGen {
+    newId(prefix: string): string;
+}
+export declare const randomIds: IdGen;
+export declare const rfc3339: (d: Date) => string;

package/dist/platform/shared/json.d.ts

@@ -0,0 +1,10 @@
+export type JsonValue = string | number | boolean | null | readonly JsonValue[] | {
+    readonly [k: string]: JsonValue;
+};
+export type JsonRecord = {
+    readonly [k: string]: JsonValue;
+};
+export declare const safeParse: (raw: string | null | undefined) => JsonValue | null;
+export declare const asRecord: (v: JsonValue | null | undefined) => JsonRecord;
+export declare const asString: (v: JsonValue | undefined) => string;
+export declare const truncate: (s: string, n: number) => string;

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@juli-os/ledger",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "juli-os L1 layer: the ledger of record for agent work — workflows, steps, case files, and token usage in one zero-dependency SQLite layer.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "juli-ledger": "./dist/juli-ledger.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && esbuild src/index.ts --bundle --platform=node --format=esm --target=node22 --outfile=dist/index.js && esbuild bin/juli-ledger.ts --bundle --platform=node --format=esm --target=node22 --outfile=dist/juli-ledger.js && chmod +x dist/juli-ledger.js && python3 scripts/postbuild.py",
+    "test": "node --test \"test/*.test.ts\"",
+    "smoke:dist": "node --input-type=module -e \"import('./dist/index.js').then(async m => { const { join } = await import('node:path'); const { tmpdir } = await import('node:os'); const s = m.createLedgerStore(join(tmpdir(), 'peel-dist-' + Date.now() + '.db')); const wf = s.createWorkflow({kind:'case',title:'dist smoke'}); if (!s.getWorkflow(wf.id)) process.exit(1); console.log('DIST SMOKE OK'); })\"",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.0",
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "license": "Apache-2.0"
 }