auden 0.1.0-alpha.2

package/dist/skill-template.js

@@ -0,0 +1,174 @@
+export const SKILL_MD = `---
+name: auden
+description: >-
+  Invoke when the user asks about Auden, evaluation results, or what happened
+  in the last session. Surfaces the current guide cache, lets the user inspect
+  or manually record verdicts, and shows pending guide suggestions. Do NOT call
+  this automatically before or after actions — Auden evaluates sessions
+  post-hoc; guides already flow into the agent's context via AGENTS.md and
+  CLAUDE.md.
+user-invocable: true
+---
+
+# Auden
+
+Auden is an on-device agent analytics layer. After each Claude Code session the Stop hook runs \`auden eval\`, which scores the session against your active guides and prints an alignment summary. Evaluation is post-hoc and happens once per session — not per action.
+
+## When To Invoke This Skill
+
+Only when the user explicitly asks. Examples:
+
+- "What did Auden say about the last session?"
+- "Show me the active guides"
+- "Did the agent follow the guides?"
+- "Run auden suggest"
+
+Do NOT call \`auden\` commands during normal task execution. Guides already reach you through \`AGENTS.md\` / \`CLAUDE.md\` / \`.cursorrules\` — Auden's job is to evaluate what happened afterwards, not to gate each action.
+
+## Commands
+
+### \`auden guides active\`
+
+Lists all currently enabled guides for this project, read from the local cache.
+
+\`\`\`bash
+auden guides active
+\`\`\`
+
+### \`auden guides search <query>\`
+
+Searches active guides by keyword.
+
+\`\`\`bash
+auden guides search "TypeScript"
+auden guides search "testing"
+\`\`\`
+
+### \`auden verdict record\`
+
+Manually records an alignment verdict and queues it for the next \`auden sync\`. Use when the user wants to log a specific outcome. The Stop hook (\`auden eval\`) evaluates sessions but does not enqueue verdicts automatically.
+
+\`\`\`bash
+auden verdict record --verdict aligned   --summary "ran tests before committing"
+auden verdict record --verdict misaligned --summary "used var instead of const"
+auden verdict record --verdict unguided  --summary "added a new pattern with no existing rule"
+\`\`\`
+
+**Verdict values:** \`aligned\` | \`misaligned\` | \`unguided\`
+
+### \`auden suggest\`
+
+Surfaces guide suggestions extracted from recent session history.
+
+\`\`\`bash
+auden suggest
+\`\`\`
+
+### \`auden sync\`
+
+Pushes queued verdicts and extracted guide/skill suggestions to the dashboard, and pulls the latest guide bundle. Verdicts recorded with \`auden verdict record\` are transmitted on the next \`auden sync\`.
+
+\`\`\`bash
+auden sync
+\`\`\`
+
+## Notes
+
+- Guides are cached in \`~/.auden/guides.json\` after \`auden sync\`. \`guides active\` and \`guides search\` read from cache — no network requests.
+- Verdicts are queued locally in \`~/.auden/queue/\` and sent to the dashboard on the next \`auden sync\` (queue files are deleted after a successful send).
+- The Stop hook (\`auden eval\`) is installed by \`auden init\` and runs once when the Claude Code session ends.
+`;
+export const AUDEN_CONTEXT_SKILL_MD = `---
+name: auden-context
+description: >-
+  Use when the user refers to their notes, context, inbox, or bundles saved in
+  Auden — e.g. "pull my notes from Auden", "what's in my inbox", "save this to
+  my context", "sync this back". Reads and writes the Auden context layer over
+  the Auden MCP server so context follows the user across every repo and agent.
+user-invocable: true
+---
+
+# Auden Context
+
+Auden's context layer is a portable store of the user's canonical documents,
+notes, and reference material. It lives on the Auden dashboard and is reachable
+from any repo through the **Auden MCP server** (\`auden mcp\`, configured once per
+agent). Items are *canonical, not copies*: a document can belong to many bundles,
+and editing it once propagates the change everywhere it is a member. Plain
+Markdown/text is the source of truth.
+
+Two surfaces sit on top of it:
+
+- **Bundles** — named collections (\`notes\`, \`travel-log\`, …) you pull scoped
+  context from and push canonical results into.
+- **Inbox** — a reserved bundle the user captures raw notes into (from the phone,
+  the app, or a share sheet). Agents pull recent inbox items, transform them, and
+  archive what they consumed.
+
+## When To Use
+
+Invoke when the user references their own saved context, for example:
+
+- "Pull my notes from the last day and summarize them."
+- "What context do I have on <topic>?" / "Search my Auden bundles for <x>."
+- "Save this document to my \`notes\` bundle." / "Sync this back to Auden."
+- "Clear my inbox once you've used it."
+
+Do NOT use it for guide/verdict inspection — that is the \`auden\` skill. This
+skill is about reading and writing *context*, not evaluating sessions.
+
+## Tools (Auden MCP server)
+
+If these tools are missing, the Auden MCP server is not configured. Tell the user
+to run \`auden mcp\` and add it to their agent's MCP config (\`.mcp.json\` / Claude
+Code / Cursor). \`auden mcp --read-only\` disables the write tools; \`auden mcp
+--bundles a,b\` restricts which bundles are visible.
+
+| Tool | Input | Use |
+|---|---|---|
+| \`list_bundles\` | \`{}\` | Discover which bundles exist before pulling or pushing. |
+| \`pull_context\` | \`{ bundle, query?, types?, limit?, writeToDir? }\` | Pull *scoped* items from a bundle. Filter with \`types\` (\`document\`/\`reference\`/\`asset\`/\`guide\`), a \`query\` substring, and \`limit\`. Pass \`writeToDir\` to also write each item to disk. |
+| \`push_context\` | \`{ bundle, name, content, contentType?, itemId?, origin?, sourceItemIds? }\` | Push a canonical item. Omit \`itemId\` to create; pass \`itemId\` to update in place (propagates to every bundle it belongs to). \`contentType\` defaults to \`document\`. When the item was produced from other context items, cite their ids as \`sourceItemIds\`. |
+| \`list_inbox\` | \`{ since?, types? }\` | List unarchived inbox items. \`since\` takes an ISO timestamp or a relative window (\`"24h"\`, \`"7d"\`, \`"30m"\`). |
+| \`pull_inbox\` | \`{ since?, types?, writeToDir? }\` | Like \`list_inbox\` but also supports \`writeToDir\` — the round-trip entry point. |
+| \`archive_inbox\` | \`{ ids }\` | Archive inbox items once consumed so they drop out of future pulls (reversible on the dashboard). |
+
+## How To Use It Well
+
+- **Pull scoped, not everything.** Reach for \`query\`/\`types\`/\`limit\` so you only
+  load what the task needs — the context layer can be large.
+- **Pushes are canonical and cross-repo.** A pushed document is visible from every
+  other repo, so name it clearly and target the right bundle. When refining
+  something you pulled, pass its \`itemId\` to \`push_context\` to update it in place
+  rather than creating a duplicate.
+- **Close the loop on the inbox.** After you turn inbox items into a saved
+  document, call \`archive_inbox\` with the ids you consumed so the user's inbox
+  reflects that they were processed.
+- **Cite your sources when transforming.** When a pushed document was produced
+  from other context items (inbox captures, bundle items), pass their ids as
+  \`sourceItemIds\` on \`push_context\`. The citation is optional provenance; if
+  one of the user's own guides covers the transform (its trigger matches, and
+  it carries eval criteria), Auden grades the round-trip against *that guide's*
+  criteria and the verdict lands in the user's feed. Auden has no built-in
+  quality bar — the user's guidance is the standard. Report the verdict from
+  the response's \`transform\` field when present.
+- **Preserve the user's facts.** These are the user's own notes — never drop or
+  invent detail when you restructure them.
+`;
+/**
+ * Skills bundled into a repo by \`auden init\` (written under .claude/skills/<name>/SKILL.md).
+ * The \`auden\` skill covers evaluation/verdict inspection; \`auden-context\` covers
+ * the context layer over the Auden MCP server.
+ *
+ * Deliberately mechanics-only: Auden ships the mechanics (pull/push/inbox/
+ * grading), users bring the use cases — a concrete transform skill (e.g. notes
+ * cleanup) plus the guide with eval criteria that grades it is *user* content.
+ * A copy-paste example lives in docs/examples/notes-cleanup-skill.md; a user
+ * skill dropped into .claude/skills/ is discovered and graded like anything
+ * else they author (L3).
+ */
+export const BUNDLED_SKILLS = [
+    { name: 'auden', content: SKILL_MD },
+    { name: 'auden-context', content: AUDEN_CONTEXT_SKILL_MD },
+];
+//# sourceMappingURL=skill-template.js.map

package/dist/skill-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-template.js","sourceRoot":"","sources":["../src/skill-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+EvB,CAAA;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4ErC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GAAqD;IAC9E,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE;IACpC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,sBAAsB,EAAE;CAC3D,CAAA"}

package/dist/sync-batches.d.ts

@@ -0,0 +1,37 @@
+import type { DashboardFeedbackCandidate, DashboardGuideSuggestion, DashboardRunUsage, DashboardSkillUsage, DashboardSyncAction, DashboardSyncRequest } from '@auden.to/protocol';
+export type SyncBatchInput = {
+    actions: DashboardSyncAction[];
+    filePaths: string[];
+    guideSuggestions: DashboardGuideSuggestion[];
+    feedbackCandidates: DashboardFeedbackCandidate[];
+    runUsage: DashboardRunUsage[];
+    skillUsage: DashboardSkillUsage[];
+};
+export type SyncBatch = {
+    payload: DashboardSyncRequest;
+    /** Queue file paths whose actions are included in this batch's payload. */
+    filePaths: string[];
+};
+/**
+ * Splits queued sync data into `POST /api/sync` request payloads that each
+ * stay under the server's `MAX_SYNC_ACTIONS_BATCH` / `MAX_SYNC_AUX_BATCH`
+ * caps. `actions` and `filePaths` are chunked in lockstep (same indices,
+ * same chunk size) since `readVerdictQueue` emits one queue file per action —
+ * this lets the caller delete only a batch's own files once that batch's
+ * request succeeds. Returns a single empty-arrays batch when there is
+ * nothing to send, so a caller can always iterate at least once.
+ *
+ * `runUsage`/`skillUsage` entries are keyed by session, not by action, and the
+ * server only creates a session's `run` row (`materializeRuns`) once that
+ * session's actions have actually been synced — so they are attached only to
+ * batches *after* every action batch, never at the same index. Aligning them
+ * index-for-index with the (differently-sized, differently-ordered) action
+ * chunks would let a usage entry for a session whose actions land in a later
+ * batch reach `/api/sync` before its run exists, silently dropping it as
+ * `no_matching_run` on a sync large enough to span multiple action batches.
+ * Batches are posted sequentially and awaited (`commands/sync.ts`), so by the
+ * time the trailing usage batches send, every prior batch's `materializeRuns`
+ * has already committed.
+ */
+export declare function buildSyncBatches(input: SyncBatchInput): SyncBatch[];
+//# sourceMappingURL=sync-batches.d.ts.map

package/dist/sync-batches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-batches.d.ts","sourceRoot":"","sources":["../src/sync-batches.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,0BAA0B,EAC1B,wBAAwB,EACxB,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,oBAAoB,CAAA;AAE3B,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,mBAAmB,EAAE,CAAA;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,gBAAgB,EAAE,wBAAwB,EAAE,CAAA;IAC5C,kBAAkB,EAAE,0BAA0B,EAAE,CAAA;IAChD,QAAQ,EAAE,iBAAiB,EAAE,CAAA;IAC7B,UAAU,EAAE,mBAAmB,EAAE,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,oBAAoB,CAAA;IAC7B,2EAA2E;IAC3E,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,EAAE,CA+DnE"}

package/dist/sync-batches.js

@@ -0,0 +1,67 @@
+import { MAX_SYNC_ACTIONS_BATCH, MAX_SYNC_AUX_BATCH } from '@auden.to/protocol';
+import { chunkArray } from './chunk.js';
+/**
+ * Splits queued sync data into `POST /api/sync` request payloads that each
+ * stay under the server's `MAX_SYNC_ACTIONS_BATCH` / `MAX_SYNC_AUX_BATCH`
+ * caps. `actions` and `filePaths` are chunked in lockstep (same indices,
+ * same chunk size) since `readVerdictQueue` emits one queue file per action —
+ * this lets the caller delete only a batch's own files once that batch's
+ * request succeeds. Returns a single empty-arrays batch when there is
+ * nothing to send, so a caller can always iterate at least once.
+ *
+ * `runUsage`/`skillUsage` entries are keyed by session, not by action, and the
+ * server only creates a session's `run` row (`materializeRuns`) once that
+ * session's actions have actually been synced — so they are attached only to
+ * batches *after* every action batch, never at the same index. Aligning them
+ * index-for-index with the (differently-sized, differently-ordered) action
+ * chunks would let a usage entry for a session whose actions land in a later
+ * batch reach `/api/sync` before its run exists, silently dropping it as
+ * `no_matching_run` on a sync large enough to span multiple action batches.
+ * Batches are posted sequentially and awaited (`commands/sync.ts`), so by the
+ * time the trailing usage batches send, every prior batch's `materializeRuns`
+ * has already committed.
+ */
+export function buildSyncBatches(input) {
+    if (input.actions.length !== input.filePaths.length) {
+        throw new Error(`buildSyncBatches: actions.length (${input.actions.length}) and filePaths.length (${input.filePaths.length}) must be equal`);
+    }
+    const actionChunks = chunkArray(input.actions, MAX_SYNC_ACTIONS_BATCH);
+    const filePathChunks = chunkArray(input.filePaths, MAX_SYNC_ACTIONS_BATCH);
+    const guideSuggestionChunks = chunkArray(input.guideSuggestions, MAX_SYNC_AUX_BATCH);
+    const feedbackCandidateChunks = chunkArray(input.feedbackCandidates, MAX_SYNC_AUX_BATCH);
+    const primaryBatchCount = Math.max(actionChunks.length, filePathChunks.length, guideSuggestionChunks.length, feedbackCandidateChunks.length) || 1;
+    const primaryBatches = Array.from({ length: primaryBatchCount }, (_, i) => ({
+        payload: {
+            actions: actionChunks[i] ?? [],
+            guideSuggestions: guideSuggestionChunks[i] ?? [],
+            feedbackCandidates: feedbackCandidateChunks[i] ?? [],
+            runUsage: [],
+            skillUsage: [],
+        },
+        filePaths: filePathChunks[i] ?? [],
+    }));
+    const runUsageChunks = chunkArray(input.runUsage, MAX_SYNC_AUX_BATCH);
+    const skillUsageChunks = chunkArray(input.skillUsage, MAX_SYNC_AUX_BATCH);
+    const usageBatchCount = Math.max(runUsageChunks.length, skillUsageChunks.length);
+    if (usageBatchCount === 0) {
+        return primaryBatches;
+    }
+    // The first usage chunk rides the last primary batch (no extra request when
+    // usage fits in one aux-sized chunk); any further chunks become trailing
+    // usage-only batches.
+    const lastPrimary = primaryBatches[primaryBatches.length - 1];
+    lastPrimary.payload.runUsage = runUsageChunks[0] ?? [];
+    lastPrimary.payload.skillUsage = skillUsageChunks[0] ?? [];
+    const trailingUsageBatches = Array.from({ length: usageBatchCount - 1 }, (_, i) => ({
+        payload: {
+            actions: [],
+            guideSuggestions: [],
+            feedbackCandidates: [],
+            runUsage: runUsageChunks[i + 1] ?? [],
+            skillUsage: skillUsageChunks[i + 1] ?? [],
+        },
+        filePaths: [],
+    }));
+    return [...primaryBatches, ...trailingUsageBatches];
+}
+//# sourceMappingURL=sync-batches.js.map

package/dist/sync-batches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-batches.js","sourceRoot":"","sources":["../src/sync-batches.ts"],"names":[],"mappings":"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"}

package/dist/sync-client.d.ts

@@ -0,0 +1,22 @@
+import type { RetryOptions } from './http-retry.js';
+import type { DashboardSyncRequest } from '@auden.to/protocol';
+export type PostSyncBatchOptions = {
+    dashboardUrl: string;
+    token: string;
+    payload: DashboardSyncRequest;
+    /** Override fetch for tests. Defaults to globalThis.fetch. */
+    fetchImpl?: typeof fetch;
+    retryOptions?: RetryOptions;
+};
+export type PostSyncBatchResult = {
+    synced: number;
+};
+/**
+ * POST one `/api/sync` batch, retrying transport failures and 5xx responses
+ * with backoff (never a 4xx — a bad request or rejected token won't be fixed
+ * by retrying). Throws on a non-2xx response or a body that doesn't match
+ * the `{ synced }` contract, so the caller's existing behaviour of keeping
+ * this batch's queue files on failure is unchanged.
+ */
+export declare function postSyncBatch(options: PostSyncBatchOptions): Promise<PostSyncBatchResult>;
+//# sourceMappingURL=sync-client.d.ts.map

package/dist/sync-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-client.d.ts","sourceRoot":"","sources":["../src/sync-client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAE9D,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,oBAAoB,CAAA;IAC7B,8DAA8D;IAC9D,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;IACxB,YAAY,CAAC,EAAE,YAAY,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAMD;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAmC9B"}

package/dist/sync-client.js

@@ -0,0 +1,38 @@
+import { fetchWithRetry } from './http-retry.js';
+import { parseSyncResponse } from './sync-response.js';
+function trimTrailingSlashes(url) {
+    return url.replace(/\/+$/, '');
+}
+/**
+ * POST one `/api/sync` batch, retrying transport failures and 5xx responses
+ * with backoff (never a 4xx — a bad request or rejected token won't be fixed
+ * by retrying). Throws on a non-2xx response or a body that doesn't match
+ * the `{ synced }` contract, so the caller's existing behaviour of keeping
+ * this batch's queue files on failure is unchanged.
+ */
+export async function postSyncBatch(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const url = `${trimTrailingSlashes(options.dashboardUrl)}/api/sync`;
+    const response = await fetchWithRetry(fetchImpl, url, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${options.token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(options.payload),
+    }, options.retryOptions);
+    if (!response.ok) {
+        throw new Error(`Sync failed with ${response.status}: ${await response.text()}`);
+    }
+    const rawBody = await response.json().catch(() => null);
+    const { synced, valid } = parseSyncResponse(rawBody);
+    if (!valid) {
+        // A 200 whose body isn't the `{ synced }` contract means we're not
+        // talking to an Auden /api/sync (e.g. a wrong --dashboard-url hitting a
+        // proxy that returns HTML). Treat it as a failure so this batch's queue
+        // files are kept and the token isn't persisted.
+        throw new Error(`Sync to ${url} returned ${response.status} but the response did not match the expected { synced } shape — keeping queued verdicts. Check that --dashboard-url points at an Auden server.`);
+    }
+    return { synced };
+}
+//# sourceMappingURL=sync-client.js.map

package/dist/sync-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-client.js","sourceRoot":"","sources":["../src/sync-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAkBtD,SAAS,mBAAmB,CAAC,GAAW;IACtC,OAAO,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;AAChC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,OAA6B;IAE7B,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,KAAK,CAAA;IAC5C,MAAM,GAAG,GAAG,GAAG,mBAAmB,CAAC,OAAO,CAAC,YAAY,CAAC,WAAW,CAAA;IAEnE,MAAM,QAAQ,GAAG,MAAM,cAAc,CACnC,SAAS,EACT,GAAG,EACH;QACE,MAAM,EAAE,MAAM;QACd,OAAO,EAAE;YACP,aAAa,EAAE,UAAU,OAAO,CAAC,KAAK,EAAE;YACxC,cAAc,EAAE,kBAAkB;SACnC;QACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC;KACtC,EACD,OAAO,CAAC,YAAY,CACrB,CAAA;IAED,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,oBAAoB,QAAQ,CAAC,MAAM,KAAK,MAAM,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;IAClF,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAA;IACvD,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAA;IACpD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,mEAAmE;QACnE,wEAAwE;QACxE,wEAAwE;QACxE,gDAAgD;QAChD,MAAM,IAAI,KAAK,CACb,WAAW,GAAG,aAAa,QAAQ,CAAC,MAAM,gJAAgJ,CAC3L,CAAA;IACH,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,CAAA;AACnB,CAAC"}

package/dist/sync-response.d.ts

@@ -0,0 +1,23 @@
+import * as v from 'valibot';
+/**
+ * Shape of a successful `POST /api/sync` response. The server returns the
+ * number of rows it persisted for the batch (`{ synced }`).
+ */
+export declare const SyncResponseSchema: v.ObjectSchema<{
+    readonly synced: v.NumberSchema<undefined>;
+}, undefined>;
+export type SyncResponse = v.InferOutput<typeof SyncResponseSchema>;
+export type ParsedSyncResponse = {
+    /** Number of items the server reported as synced (0 when the shape drifted). */
+    synced: number;
+    /** False when the body did not match the expected contract. */
+    valid: boolean;
+};
+/**
+ * Validate a `/api/sync` response body without throwing. A 200 response means
+ * the items were already persisted server-side, so a drifted shape must not
+ * fail the sync — it is surfaced via `valid: false` and counted as 0 so the
+ * caller can warn while still treating the push as accepted.
+ */
+export declare function parseSyncResponse(raw: unknown): ParsedSyncResponse;
+//# sourceMappingURL=sync-response.d.ts.map

package/dist/sync-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-response.d.ts","sourceRoot":"","sources":["../src/sync-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;aAE7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gFAAgF;IAChF,MAAM,EAAE,MAAM,CAAA;IACd,+DAA+D;IAC/D,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,CAMlE"}

package/dist/sync-response.js

@@ -0,0 +1,22 @@
+import * as v from 'valibot';
+/**
+ * Shape of a successful `POST /api/sync` response. The server returns the
+ * number of rows it persisted for the batch (`{ synced }`).
+ */
+export const SyncResponseSchema = v.object({
+    synced: v.number(),
+});
+/**
+ * Validate a `/api/sync` response body without throwing. A 200 response means
+ * the items were already persisted server-side, so a drifted shape must not
+ * fail the sync — it is surfaced via `valid: false` and counted as 0 so the
+ * caller can warn while still treating the push as accepted.
+ */
+export function parseSyncResponse(raw) {
+    const result = v.safeParse(SyncResponseSchema, raw);
+    if (result.success) {
+        return { synced: result.output.synced, valid: true };
+    }
+    return { synced: 0, valid: false };
+}
+//# sourceMappingURL=sync-response.js.map

package/dist/sync-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-response.js","sourceRoot":"","sources":["../src/sync-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;CACnB,CAAC,CAAA;AAWF;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY;IAC5C,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAA;IACnD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;IACtD,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;AACpC,CAAC"}

package/dist/token-verify.d.ts

@@ -0,0 +1,14 @@
+export type TokenVerification = 'ok' | 'rejected' | 'unreachable';
+/**
+ * Probe the dashboard with a bearer token to classify it before storing.
+ * Hits the same endpoint `auden sync` pulls guides from, with a short
+ * timeout so `auden init --token` stays fast even when the host is down.
+ *
+ * - 'ok'          — the server accepted the token
+ * - 'rejected'    — the server answered 401/403: the token itself is bad
+ * - 'unreachable' — network failure, timeout, or a non-auth error (5xx);
+ *                   says nothing about the token, so callers should store
+ *                   it and let the next `auden sync` settle the question
+ */
+export declare function verifyDashboardToken(dashboardUrl: string, token: string, fetchFn?: typeof fetch): Promise<TokenVerification>;
+//# sourceMappingURL=token-verify.d.ts.map

package/dist/token-verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-verify.d.ts","sourceRoot":"","sources":["../src/token-verify.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,UAAU,GAAG,aAAa,CAAA;AAEjE;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,OAAO,KAAa,GAC5B,OAAO,CAAC,iBAAiB,CAAC,CAc5B"}

package/dist/token-verify.js

@@ -0,0 +1,30 @@
+/**
+ * Probe the dashboard with a bearer token to classify it before storing.
+ * Hits the same endpoint `auden sync` pulls guides from, with a short
+ * timeout so `auden init --token` stays fast even when the host is down.
+ *
+ * - 'ok'          — the server accepted the token
+ * - 'rejected'    — the server answered 401/403: the token itself is bad
+ * - 'unreachable' — network failure, timeout, or a non-auth error (5xx);
+ *                   says nothing about the token, so callers should store
+ *                   it and let the next `auden sync` settle the question
+ */
+export async function verifyDashboardToken(dashboardUrl, token, fetchFn = fetch) {
+    const url = `${dashboardUrl.replace(/\/+$/, '')}/api/v1/guides`;
+    let response;
+    try {
+        response = await fetchFn(url, {
+            headers: { Authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(5000),
+        });
+    }
+    catch {
+        return 'unreachable';
+    }
+    if (response.ok)
+        return 'ok';
+    if (response.status === 401 || response.status === 403)
+        return 'rejected';
+    return 'unreachable';
+}
+//# sourceMappingURL=token-verify.js.map

package/dist/token-verify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-verify.js","sourceRoot":"","sources":["../src/token-verify.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,YAAoB,EACpB,KAAa,EACb,UAAwB,KAAK;IAE7B,MAAM,GAAG,GAAG,GAAG,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,gBAAgB,CAAA;IAC/D,IAAI,QAAkB,CAAA;IACtB,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,EAAE;YAC5B,OAAO,EAAE,EAAE,aAAa,EAAE,UAAU,KAAK,EAAE,EAAE;YAC7C,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC;SAClC,CAAC,CAAA;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,aAAa,CAAA;IACtB,CAAC;IACD,IAAI,QAAQ,CAAC,EAAE;QAAE,OAAO,IAAI,CAAA;IAC5B,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG;QAAE,OAAO,UAAU,CAAA;IACzE,OAAO,aAAa,CAAA;AACtB,CAAC"}

package/dist/usage/extract.d.ts

@@ -0,0 +1,31 @@
+import type { SkillUsageEntry, TokenUsage } from '@auden.to/protocol';
+export type SessionUsage = {
+    sessionId: string;
+    usage: TokenUsage[];
+};
+export type SessionSkillUsage = {
+    sessionId: string;
+    usage: SkillUsageEntry[];
+};
+export type ExtractedRunUsage = {
+    runUsage: SessionUsage[];
+    skillUsage: SessionSkillUsage[];
+};
+/**
+ * Extracts per-session, per-model token usage from Claude Code JSONL
+ * transcripts (docs/plans/token-cost-tracking-plan.md §5.1), plus per-skill
+ * Tier-1 "load overhead" usage (§13.3): when an assistant message requests a
+ * `Skill` tool or reads a `SKILL.md`, the *next* assistant message's usage is
+ * the first-load cost of that skill (v1 approximation — see §13.3's caching
+ * nuance). Reads only `usage`/`model`/`sessionId` and tool_use `name`/`input`
+ * off assistant messages — never message text.
+ *
+ * Each message carries its own (non-cumulative) usage, so we sum every
+ * assistant message's usage per (session, model). Messages are deduped by
+ * their id so re-reading a transcript that grew since the last sync does not
+ * double-count lines already summed.
+ */
+export declare function extractRunUsage(options?: {
+    transcriptsDir?: string;
+}): Promise<ExtractedRunUsage>;
+//# sourceMappingURL=extract.d.ts.map

package/dist/usage/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/usage/extract.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAErE,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,eAAe,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,UAAU,EAAE,iBAAiB,EAAE,CAAA;CAChC,CAAA;AAiGD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,eAAe,CAAC,OAAO,CAAC,EAAE;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAkI7B"}