@aitne/daemon 0.1.7 → 0.1.9

package/dist/api/routes/obsidian.js

@@ -2,6 +2,7 @@ import { Hono } from "hono";
 import { existsSync } from "node:fs";
 import { createLogger, toSafeErrorMessage } from "../../logging.js";
 import { readJsonBody } from "../json-body.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 const logger = createLogger("obsidian-api");
 /**
  * Obsidian API routes — proxies to the Obsidian CLI via ObsidianService.
@@ -104,17 +105,32 @@ export function createObsidianRoutes(deps) {
     // GET /obsidian/notes/* — read a specific note's content
     app.get("/obsidian/notes/*", async (c) => {
         if (!obsidianService?.available) {
-            return c.json({ error: "obsidian_not_configured" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("obsidian.not_configured", {
+                    field: "externalObsidianVaultPath",
+                    received: "<unset>",
+                }),
+            ]);
         }
         // Extract path after /obsidian/notes/
         const filePath = c.req.path.replace(/^.*\/obsidian\/notes\//, "");
         if (!filePath || !isValidNotePath(filePath)) {
-            return c.json({ error: "invalid file path" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.invalid_path", {
+                    field: "path",
+                    received: filePath,
+                }),
+            ]);
         }
         try {
             const running = await obsidianService.isRunning();
             if (!running) {
-                return c.json({ error: "obsidian_not_running", message: "Obsidian app is not running" }, 503);
+                return respondWithAgentError(c, 503, [
+                    composeIssue("obsidian.not_running", {
+                        field: "obsidian.app",
+                        received: "<not_running>",
+                    }),
+                ]);
             }
             const content = await obsidianService.readNote(filePath);
             return c.json({ content, path: filePath });
@@ -123,52 +139,97 @@ export function createObsidianRoutes(deps) {
             // Obsidian CLI doesn't distinguish "not found" from other read failures,
             // so we collapse all errors to 404 but log for observability.
             logger.warn({ err, path: filePath }, "Obsidian note read failed");
-            return c.json({ error: "not_found", message: toSafeErrorMessage(err) }, 404);
+            return respondWithAgentError(c, 404, [
+                composeIssue("obsidian.not_found", {
+                    field: "path",
+                    received: filePath,
+                }),
+            ], { legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     // GET /obsidian/search — search notes
     app.get("/obsidian/search", async (c) => {
         if (!obsidianService?.available) {
-            return c.json({ error: "obsidian_not_configured" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("obsidian.not_configured", {
+                    field: "externalObsidianVaultPath",
+                    received: "<unset>",
+                }),
+            ]);
         }
         const q = c.req.query("q");
         if (!q) {
-            return c.json({ error: "query parameter 'q' is required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.query_required", {
+                    field: "q",
+                    received: "<missing>",
+                }),
+            ]);
         }
         const limit = Math.min(Number(c.req.query("limit") ?? "10"), 50);
         try {
             const running = await obsidianService.isRunning();
             if (!running) {
-                return c.json({ error: "obsidian_not_running", message: "Obsidian app is not running" }, 503);
+                return respondWithAgentError(c, 503, [
+                    composeIssue("obsidian.not_running", {
+                        field: "obsidian.app",
+                        received: "<not_running>",
+                    }),
+                ]);
             }
             const results = await obsidianService.search(q, limit);
             return c.json({ results });
         }
         catch (err) {
             logger.error({ err }, "Obsidian search failed");
-            return c.json({ error: "obsidian_error", message: toSafeErrorMessage(err) }, 502);
+            return respondWithAgentError(c, 502, [
+                composeIssue("obsidian.upstream_error", {
+                    field: "obsidian.cli",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     // POST /obsidian/notes — create a new note
     app.post("/obsidian/notes", async (c) => {
         if (!obsidianService?.available) {
-            return c.json({ error: "obsidian_not_configured" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("obsidian.not_configured", {
+                    field: "externalObsidianVaultPath",
+                    received: "<unset>",
+                }),
+            ]);
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const { name, content } = parsedBody.body;
         if (!name || !content) {
-            return c.json({ error: "name and content are required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.name_and_content_required", {
+                    field: "body",
+                    received: { name: name ?? "<missing>", content: content ? "<set>" : "<missing>" },
+                }),
+            ]);
         }
         if (!isValidNotePath(name)) {
-            return c.json({ error: "invalid note name" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.invalid_note_name", {
+                    field: "name",
+                    received: name,
+                }),
+            ]);
         }
         return withWriteLock(async () => {
             try {
                 const running = await obsidianService.isRunning();
                 if (!running) {
-                    return c.json({ error: "obsidian_not_running", message: "Obsidian app is not running" }, 503);
+                    return respondWithAgentError(c, 503, [
+                        composeIssue("obsidian.not_running", {
+                            field: "obsidian.app",
+                            received: "<not_running>",
+                        }),
+                    ]);
                 }
                 markAgentWrite(name);
                 await obsidianService.createNote(name, content);
@@ -176,31 +237,56 @@ export function createObsidianRoutes(deps) {
             }
             catch (err) {
                 logger.error({ err }, "Obsidian create note failed");
-                return c.json({ error: "obsidian_error", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("obsidian.upstream_error", {
+                        field: "obsidian.cli",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
     // PUT /obsidian/notes/* — create or overwrite a note (idempotent edit)
     app.put("/obsidian/notes/*", async (c) => {
         if (!obsidianService?.available) {
-            return c.json({ error: "obsidian_not_configured" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("obsidian.not_configured", {
+                    field: "externalObsidianVaultPath",
+                    received: "<unset>",
+                }),
+            ]);
         }
         const filePath = c.req.path.replace(/^.*\/obsidian\/notes\//, "");
         if (!filePath || !isValidNotePath(filePath)) {
-            return c.json({ error: "invalid file path" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.invalid_path", {
+                    field: "path",
+                    received: filePath,
+                }),
+            ]);
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const { content } = parsedBody.body;
         if (typeof content !== "string") {
-            return c.json({ error: "content is required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.content_required", {
+                    field: "content",
+                    received: content === undefined ? "<missing>" : typeof content,
+                }),
+            ]);
         }
         return withWriteLock(async () => {
             try {
                 const running = await obsidianService.isRunning();
                 if (!running) {
-                    return c.json({ error: "obsidian_not_running", message: "Obsidian app is not running" }, 503);
+                    return respondWithAgentError(c, 503, [
+                        composeIssue("obsidian.not_running", {
+                            field: "obsidian.app",
+                            received: "<not_running>",
+                        }),
+                    ]);
                 }
                 markAgentWrite(filePath);
                 await obsidianService.updateNote(filePath, content);
@@ -208,18 +294,33 @@ export function createObsidianRoutes(deps) {
             }
             catch (err) {
                 logger.error({ err }, "Obsidian update note failed");
-                return c.json({ error: "obsidian_error", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("obsidian.upstream_error", {
+                        field: "obsidian.cli",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
     // DELETE /obsidian/notes/* — delete a note (trash by default)
     app.delete("/obsidian/notes/*", async (c) => {
         if (!obsidianService?.available) {
-            return c.json({ error: "obsidian_not_configured" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("obsidian.not_configured", {
+                    field: "externalObsidianVaultPath",
+                    received: "<unset>",
+                }),
+            ]);
         }
         const filePath = c.req.path.replace(/^.*\/obsidian\/notes\//, "");
         if (!filePath || !isValidNotePath(filePath)) {
-            return c.json({ error: "invalid file path" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.invalid_path", {
+                    field: "path",
+                    received: filePath,
+                }),
+            ]);
         }
         // Default to trash (recoverable). Opt in to permanent deletion via
         // ?permanent=true — irreversible, so require an explicit query flag.
@@ -228,7 +329,12 @@ export function createObsidianRoutes(deps) {
             try {
                 const running = await obsidianService.isRunning();
                 if (!running) {
-                    return c.json({ error: "obsidian_not_running", message: "Obsidian app is not running" }, 503);
+                    return respondWithAgentError(c, 503, [
+                        composeIssue("obsidian.not_running", {
+                            field: "obsidian.app",
+                            received: "<not_running>",
+                        }),
+                    ]);
                 }
                 // Pre-check existence on disk so we can return an idempotent 404
                 // rather than propagating an opaque CLI error as 502. The
@@ -239,7 +345,12 @@ export function createObsidianRoutes(deps) {
                 // which case we already bailed at the `available` check above.
                 const absolute = obsidianService.resolveNotePath(filePath);
                 if (absolute && !existsSync(absolute)) {
-                    return c.json({ error: "not_found", path: filePath }, 404);
+                    return respondWithAgentError(c, 404, [
+                        composeIssue("obsidian.not_found", {
+                            field: "path",
+                            received: filePath,
+                        }),
+                    ], { legacyFields: { path: filePath } });
                 }
                 markAgentWrite(filePath);
                 await obsidianService.deleteNote(filePath, permanent);
@@ -247,30 +358,55 @@ export function createObsidianRoutes(deps) {
             }
             catch (err) {
                 logger.error({ err }, "Obsidian delete note failed");
-                return c.json({ error: "obsidian_error", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("obsidian.upstream_error", {
+                        field: "obsidian.cli",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
     // PATCH /obsidian/notes — append to an existing note
     app.patch("/obsidian/notes", async (c) => {
         if (!obsidianService?.available) {
-            return c.json({ error: "obsidian_not_configured" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("obsidian.not_configured", {
+                    field: "externalObsidianVaultPath",
+                    received: "<unset>",
+                }),
+            ]);
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const { file, content } = parsedBody.body;
         if (!file || !content) {
-            return c.json({ error: "file and content are required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.file_and_content_required", {
+                    field: "body",
+                    received: { file: file ?? "<missing>", content: content ? "<set>" : "<missing>" },
+                }),
+            ]);
         }
         if (!isValidNotePath(file)) {
-            return c.json({ error: "invalid file path" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.invalid_path", {
+                    field: "file",
+                    received: file,
+                }),
+            ]);
         }
         return withWriteLock(async () => {
             try {
                 const running = await obsidianService.isRunning();
                 if (!running) {
-                    return c.json({ error: "obsidian_not_running", message: "Obsidian app is not running" }, 503);
+                    return respondWithAgentError(c, 503, [
+                        composeIssue("obsidian.not_running", {
+                            field: "obsidian.app",
+                            received: "<not_running>",
+                        }),
+                    ]);
                 }
                 markAgentWrite(file);
                 await obsidianService.appendToNote(file, content);
@@ -278,27 +414,47 @@ export function createObsidianRoutes(deps) {
             }
             catch (err) {
                 logger.error({ err }, "Obsidian append failed");
-                return c.json({ error: "obsidian_error", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("obsidian.upstream_error", {
+                        field: "obsidian.cli",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
     // PATCH /obsidian/daily — append to daily note
     app.patch("/obsidian/daily", async (c) => {
         if (!obsidianService?.available) {
-            return c.json({ error: "obsidian_not_configured" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("obsidian.not_configured", {
+                    field: "externalObsidianVaultPath",
+                    received: "<unset>",
+                }),
+            ]);
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const { content } = parsedBody.body;
         if (!content) {
-            return c.json({ error: "content is required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("obsidian.content_required", {
+                    field: "content",
+                    received: content === undefined ? "<missing>" : "<empty>",
+                }),
+            ]);
         }
         return withWriteLock(async () => {
             try {
                 const running = await obsidianService.isRunning();
                 if (!running) {
-                    return c.json({ error: "obsidian_not_running", message: "Obsidian app is not running" }, 503);
+                    return respondWithAgentError(c, 503, [
+                        composeIssue("obsidian.not_running", {
+                            field: "obsidian.app",
+                            received: "<not_running>",
+                        }),
+                    ]);
                 }
                 // Daily note attribution: Obsidian's daily note convention is typically
                 // `YYYY-MM-DD.md`, but the actual folder depends on per-vault settings.
@@ -312,10 +468,14 @@ export function createObsidianRoutes(deps) {
             }
             catch (err) {
                 logger.error({ err }, "Obsidian daily append failed");
-                return c.json({ error: "obsidian_error", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("obsidian.upstream_error", {
+                        field: "obsidian.cli",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
     return app;
 }
-//# sourceMappingURL=obsidian.js.map

package/dist/api/routes/profile-questions.d.ts

@@ -14,4 +14,3 @@
 import { Hono } from "hono";
 import type { ApiDependencies } from "../server.js";
 export declare function createProfileQuestionsRoutes(deps: ApiDependencies): Hono;
-//# sourceMappingURL=profile-questions.d.ts.map

package/dist/api/routes/profile-questions.js

@@ -15,8 +15,10 @@ import { Hono } from "hono";
 import { existsSync, readFileSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { getContextDir } from "../../config.js";
+import { aliasVaultPath } from "../../core/context-vault-aliases.js";
 import { isSlotFilled } from "../../core/profile-questions/slot-filled.js";
 import { createLogger } from "../../logging.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 const logger = createLogger("profile-questions-api");
 export function createProfileQuestionsRoutes(deps) {
     const app = new Hono();
@@ -26,7 +28,7 @@ export function createProfileQuestionsRoutes(deps) {
      *
      * Query:
      *   path     (required) Relative path under contextDir,
-     *                       e.g. `user/profile.md`. The trailing `.md`
+     *                       e.g. `identity/profile.md`. The trailing `.md`
      *                       can be omitted; `.base` files are not accepted
      *                       (this endpoint is for prose-bearing markdown).
      *   section  (optional) Heading text without leading `## ` —
@@ -44,12 +46,22 @@ export function createProfileQuestionsRoutes(deps) {
         const section = c.req.query("section") ?? null;
         const anchor = c.req.query("anchor") ?? null;
         if (!path || path.trim().length === 0) {
-            return c.json({ error: "missing_path", details: "Query parameter 'path' is required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("profile_questions.path_required", {
+                    field: "path",
+                    received: path ?? "<missing>",
+                }),
+            ], { legacyFields: { details: "Query parameter 'path' is required" } });
         }
         const contextDir = getCurrentContextDir();
         const resolved = safePath(contextDir, path);
         if (resolved === null) {
-            return c.json({ error: "invalid_path" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("profile_questions.path_invalid", {
+                    field: "path",
+                    received: path,
+                }),
+            ]);
         }
         if (!existsSync(resolved)) {
             return c.json({
@@ -67,7 +79,12 @@ export function createProfileQuestionsRoutes(deps) {
         }
         catch (err) {
             logger.warn({ err, resolved, path }, "Failed to read target for slot-filled probe");
-            return c.json({ error: "read_failed" }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("profile_questions.read_failed", {
+                    field: "path",
+                    received: path,
+                }),
+            ]);
         }
         const result = isSlotFilled(body, section, anchor);
         return c.json({
@@ -100,6 +117,11 @@ function safePath(contextDir, userPath) {
     let candidate = userPath;
     if (candidate.endsWith(".base"))
         return null;
+    // CONTEXT_VAULT_REDESIGN: translate legacy paths (e.g. `identity/profile`)
+    // to their canonical six-class destinations (`identity/profile`) so
+    // skill code calling the route with either spelling resolves to the
+    // same file.
+    candidate = aliasVaultPath(candidate).canonicalPath;
     if (!candidate.endsWith(".md"))
         candidate = `${candidate}.md`;
     const resolved = resolve(contextDir, candidate);
@@ -112,4 +134,3 @@ function safePath(contextDir, userPath) {
     /* c8 ignore stop */
     return resolved;
 }
-//# sourceMappingURL=profile-questions.js.map

package/dist/api/routes/receipts.d.ts

@@ -1,4 +1,3 @@
 import { Hono } from "hono";
 import type { ApiDependencies } from "../server.js";
 export declare function createReceiptRoutes(deps: ApiDependencies): Hono;
-//# sourceMappingURL=receipts.d.ts.map

package/dist/api/routes/receipts.js

@@ -1,5 +1,6 @@
 import { Hono } from "hono";
 import { readJsonBody } from "../json-body.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 export function createReceiptRoutes(deps) {
     const app = new Hono();
     const { db } = deps;
@@ -79,41 +80,72 @@ export function createReceiptRoutes(deps) {
      * than guess at a provider.
      */
     app.post("/receipts/:id/download", async (c) => {
-        const id = parseInt(c.req.param("id"), 10);
-        if (isNaN(id))
-            return c.json({ error: "invalid_id" }, 400);
+        const rawId = c.req.param("id");
+        const id = parseInt(rawId, 10);
+        if (isNaN(id) || id <= 0) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("receipts.invalid_id", { field: "id", received: rawId }),
+            ]);
+        }
         const row = db.prepare(`SELECT provider_msg_id, attachment_id, filename, mime_type, size_bytes, account_id
        FROM receipts WHERE id = ?`).get(id);
-        if (!row)
-            return c.json({ error: "not_found" }, 404);
+        if (!row) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("receipts.not_found", { field: "id", received: id }),
+            ]);
+        }
         // Reject oversized attachments to prevent OOM (100 MB limit)
         const MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
         if (row.size_bytes && row.size_bytes > MAX_DOWNLOAD_BYTES) {
-            return c.json({ error: "attachment_too_large", maxBytes: MAX_DOWNLOAD_BYTES }, 413);
+            return respondWithAgentError(c, 413, [
+                composeIssue("receipts.attachment_too_large", {
+                    field: "size_bytes",
+                    received: row.size_bytes,
+                }),
+            ], { legacyFields: { maxBytes: MAX_DOWNLOAD_BYTES } });
         }
         if (!deps.services.mail) {
-            return c.json({ error: "mail_not_configured" }, 503);
+            return respondWithAgentError(c, 503, [
+                composeIssue("receipts.mail_not_configured", {
+                    field: "services.mail",
+                    received: "<unavailable>",
+                }),
+            ]);
         }
         if (!row.account_id) {
-            return c.json({
-                error: "orphaned_receipt",
-                hint: "Receipt row has no linked mail account. This can only happen on installs where the Gmail identity was never configured; add Gmail in /connections/mail and re-run the migration, or re-import the receipt.",
-            }, 409);
+            return respondWithAgentError(c, 409, [
+                composeIssue("receipts.orphaned_receipt", {
+                    field: "account_id",
+                    received: null,
+                }),
+            ]);
         }
         const provider = await deps.services.mail.getProvider(row.account_id);
         if (!provider) {
-            return c.json({ error: "account_not_found", accountId: row.account_id }, 404);
+            return respondWithAgentError(c, 404, [
+                composeIssue("receipts.account_not_found", {
+                    field: "account_id",
+                    received: row.account_id,
+                }),
+            ], { legacyFields: { accountId: row.account_id } });
         }
         if (typeof provider.getAttachment !== "function") {
-            return c.json({
-                error: "attachment_download_not_supported",
-                provider: provider.kind,
-                hint: "Use the provider's native web client to download this attachment.",
-            }, 501);
+            return respondWithAgentError(c, 501, [
+                composeIssue("receipts.attachment_download_not_supported", {
+                    field: "provider.kind",
+                    received: provider.kind,
+                }),
+            ], { legacyFields: { provider: provider.kind } });
         }
         const attachment = await provider.getAttachment(row.provider_msg_id, row.attachment_id);
-        if (!attachment)
-            return c.json({ error: "attachment_not_found" }, 404);
+        if (!attachment) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("receipts.attachment_not_found", {
+                    field: "attachment",
+                    received: { provider_msg_id: row.provider_msg_id, attachment_id: row.attachment_id },
+                }),
+            ]);
+        }
         c.header("Content-Type", row.mime_type);
         c.header("Content-Disposition", `attachment; filename="${row.filename}"`);
         return c.body(new Uint8Array(attachment.data));
@@ -122,9 +154,13 @@ export function createReceiptRoutes(deps) {
      * PATCH /receipts/:id — update receipt metadata.
      */
     app.patch("/receipts/:id", async (c) => {
-        const id = parseInt(c.req.param("id"), 10);
-        if (isNaN(id))
-            return c.json({ error: "invalid_id" }, 400);
+        const rawId = c.req.param("id");
+        const id = parseInt(rawId, 10);
+        if (isNaN(id) || id <= 0) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("receipts.invalid_id", { field: "id", received: rawId }),
+            ]);
+        }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
@@ -141,15 +177,18 @@ export function createReceiptRoutes(deps) {
             params.push(body.category);
         }
         if (updates.length === 0) {
-            return c.json({ error: "no_updates" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("receipts.no_updates", { field: "body", received: body }),
+            ]);
         }
         params.push(id);
         const result = db.prepare(`UPDATE receipts SET ${updates.join(", ")} WHERE id = ?`).run(...params);
         if (result.changes === 0) {
-            return c.json({ error: "not_found" }, 404);
+            return respondWithAgentError(c, 404, [
+                composeIssue("receipts.not_found", { field: "id", received: id }),
+            ]);
         }
         return c.json({ ok: true, id });
     });
     return app;
 }
-//# sourceMappingURL=receipts.js.map

package/dist/api/routes/recurring-schedules.d.ts

@@ -1,4 +1,3 @@
 import { Hono } from "hono";
 import type { ApiDependencies } from "../server.js";
 export declare function createRecurringScheduleRoutes(deps: ApiDependencies): Hono;
-//# sourceMappingURL=recurring-schedules.d.ts.map