@aitne/daemon 0.1.7 → 0.1.9

package/dist/api/routes/skills.js

@@ -5,9 +5,11 @@ import { join, resolve, relative } from "node:path";
 import { skillCreateSchema, skillUpdateSchema, skillNameSchema, } from "@aitne/shared";
 import { createLogger, toSafeErrorMessage } from "../../logging.js";
 import { SkillsCompiler } from "../../core/skills-compiler.js";
+import { resolveUserSkillsRoot } from "../../core/user-skills-root.js";
 import { listBuiltinSkillDirs, resolveBuiltinSkillDir, } from "../../core/skill-source-paths.js";
 import { getProfileForProcess, getSkillsForProcess } from "../../core/skills-manifest.js";
 import { readJsonBody } from "../json-body.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 const logger = createLogger("skills-api");
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
 /** Unescape a double-quoted YAML scalar (backslash + double-quote escapes). */
@@ -203,10 +205,17 @@ function listSkillDetailsInRoot(root, builtin) {
     }
     return out;
 }
+// `resolveUserSkillsRoot` lives in `core/user-skills-root.ts` — re-export
+// from there so existing API consumers continue to import from this module.
+export { resolveUserSkillsRoot };
 export function createSkillsRoutes(deps) {
     const app = new Hono();
     const { config } = deps;
-    const userSkillsRoot = resolve(config.dataDir, "skills");
+    // CONTEXT_VAULT_REDESIGN_PLAN.md §11.6 (v3.1 V5) — user skills root
+    // moved from `<dataDir>/skills/` to `<contextDir>/policies/skills/`.
+    // The vault-restructure migration moves any pre-existing slug
+    // directories on first boot post-upgrade.
+    const userSkillsRoot = resolveUserSkillsRoot(config);
     // Default workspaceDir to cwd if the config stub omits it (test fixtures).
     const workspaceDir = config.workspaceDir ?? process.cwd();
     const builtinSkillsRoot = resolve(workspaceDir, "agent-assets", "skills");
@@ -278,38 +287,67 @@ export function createSkillsRoutes(deps) {
     // than treating it as a :name parameter.
     async function handleUpload(c) {
         const form = await c.req.formData().catch(() => null);
-        if (!form)
-            return c.json({ error: "invalid_form" }, 400);
+        if (!form) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("skills.invalid_form", {
+                    field: "body",
+                    received: "<unparseable multipart>",
+                }),
+            ]);
+        }
         const file = form.get("file");
         const nameOverride = form.get("name") ?? null;
         if (!(file instanceof File)) {
-            return c.json({ error: "file field required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("skills.file_field_required", {
+                    field: "file",
+                    received: "<missing>",
+                }),
+            ]);
         }
         // Derive slug from override, filename (stripping .md), or parent folder name
         const fallback = file.name.replace(/\.md$/i, "").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
         const slug = nameOverride ?? fallback;
         const slugCheck = skillNameSchema.safeParse(slug);
         if (!slugCheck.success) {
-            return c.json({ error: "invalid_name", message: slugCheck.error.issues[0]?.message, slug }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("skills.invalid_name", { field: "name", received: slug })], {
+                legacyFields: {
+                    message: slugCheck.error.issues[0]?.message,
+                    slug,
+                },
+            });
         }
         if (isBuiltinSlug(slug)) {
-            return c.json({ error: "builtin_protected", name: slug }, 403);
+            return respondWithAgentError(c, 403, [composeIssue("skills.builtin_protected", { field: "name", received: slug })], { legacyFields: { name: slug } });
         }
         const rawBuf = Buffer.from(await file.arrayBuffer());
         if (rawBuf.length > 256 * 1024) {
-            return c.json({ error: "file_too_large", maxBytes: 256 * 1024 }, 413);
+            return respondWithAgentError(c, 413, [
+                composeIssue("skills.file_too_large", {
+                    field: "file",
+                    received: rawBuf.length,
+                }),
+            ], { legacyFields: { maxBytes: 256 * 1024 } });
         }
         // Reject non-UTF-8 (e.g. a binary file renamed to .md). Without this
         // check, toString("utf-8") silently inserts replacement chars and we'd
         // write garbage to the skill file.
         if (!isUtf8(rawBuf)) {
-            return c.json({ error: "invalid_encoding", message: "file must be valid UTF-8" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("skills.invalid_encoding", {
+                    field: "file",
+                    received: "<not UTF-8>",
+                }),
+            ], { legacyFields: { message: "file must be valid UTF-8" } });
         }
         const raw = rawBuf.toString("utf-8");
         const { description, body, allowedTools } = parseSkillFile(raw);
         const content = body.replace(/^\n/, "");
-        if (!content)
-            return c.json({ error: "empty_content" }, 400);
+        if (!content) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("skills.empty_content", { field: "content", received: "<empty>" }),
+            ]);
+        }
         // Reject descriptions with embedded newlines even when parsed from an
         // upload — the regex-based parser can't round-trip them safely.
         // The `^description:\s*(.*)$` regex in parseSkillFile can never return
@@ -317,15 +355,17 @@ export function createSkillsRoutes(deps) {
         // both \r and \n), so this branch is unreachable in practice.
         /* c8 ignore start */
         if (/[\r\n]/.test(description)) {
-            return c.json({ error: "invalid_description", message: "description cannot contain newlines" }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("skills.invalid_description", { field: "description", received: description })], { legacyFields: { message: "description cannot contain newlines" } });
         }
         /* c8 ignore stop */
         const skillFile = safeSkillPath(userSkillsRoot, slug);
         // skillFile is null only for traversal slugs; the zod slug check above
         // already rejects those — this null branch is unreachable for valid slugs.
-        /* c8 ignore next */
-        if (!skillFile)
-            return c.json({ error: "invalid_name", name: slug }, 400);
+        /* c8 ignore start */
+        if (!skillFile) {
+            return respondWithAgentError(c, 400, [composeIssue("skills.invalid_name", { field: "name", received: slug })], { legacyFields: { name: slug } });
+        }
+        /* c8 ignore stop */
         try {
             mkdirSync(join(userSkillsRoot, slug), { recursive: true });
             const existed = existsSync(skillFile);
@@ -337,7 +377,8 @@ export function createSkillsRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, name: slug }, "Skill upload failed");
-            return c.json({ error: "write_failed", message: toSafeErrorMessage(err) }, 500);
+            const message = toSafeErrorMessage(err);
+            return respondWithAgentError(c, 500, [composeIssue("skills.write_failed", { field: "write", received: message })], { legacyFields: { message } });
         }
         /* c8 ignore stop */
     }
@@ -370,11 +411,12 @@ export function createSkillsRoutes(deps) {
         const name = c.req.param("name");
         const slugCheck = skillNameSchema.safeParse(name);
         if (!slugCheck.success) {
-            return c.json({ error: "invalid_name", message: slugCheck.error.issues[0]?.message }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("skills.invalid_name", { field: "name", received: name })], { legacyFields: { message: slugCheck.error.issues[0]?.message } });
         }
         const skill = loadSkill(name);
-        if (!skill)
-            return c.json({ error: "not_found", name }, 404);
+        if (!skill) {
+            return respondWithAgentError(c, 404, [composeIssue("skills.not_found", { field: "name", received: name })], { legacyFields: { name } });
+        }
         return c.json(skill);
     });
     // POST /skills — create a new user skill (JSON body)
@@ -384,22 +426,27 @@ export function createSkillsRoutes(deps) {
             return parsedBody.response;
         const parsed = skillCreateSchema.safeParse(parsedBody.body);
         if (!parsed.success) {
-            return c.json({ error: "validation_error", details: parsed.error.issues }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("skills.validation_error", { field: "body", received: parsedBody.body })], { legacyFields: { details: parsed.error.issues } });
         }
         const { name, description, content, allowedTools } = parsed.data;
         if (isBuiltinSlug(name)) {
-            return c.json({ error: "builtin_protected", name, message: "Built-in skills cannot be modified by this API" }, 403);
+            return respondWithAgentError(c, 403, [composeIssue("skills.builtin_protected", { field: "name", received: name })], {
+                legacyFields: {
+                    name,
+                    message: "Built-in skills cannot be modified by this API",
+                },
+            });
         }
         const skillFile = safeSkillPath(userSkillsRoot, name);
         // skillFile is null only for traversal slugs; zod validation above
         // already rejects those — this branch is unreachable for valid slugs.
         /* c8 ignore start */
         if (!skillFile) {
-            return c.json({ error: "invalid_name", name }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("skills.invalid_name", { field: "name", received: name })], { legacyFields: { name } });
         }
         /* c8 ignore stop */
         if (existsSync(skillFile)) {
-            return c.json({ error: "already_exists", name }, 409);
+            return respondWithAgentError(c, 409, [composeIssue("skills.already_exists", { field: "name", received: name })], { legacyFields: { name } });
         }
         try {
             mkdirSync(join(userSkillsRoot, name), { recursive: true });
@@ -410,7 +457,8 @@ export function createSkillsRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, name }, "Skill create failed");
-            return c.json({ error: "write_failed", message: toSafeErrorMessage(err) }, 500);
+            const message = toSafeErrorMessage(err);
+            return respondWithAgentError(c, 500, [composeIssue("skills.write_failed", { field: "write", received: message })], { legacyFields: { message } });
         }
         /* c8 ignore stop */
     });
@@ -419,21 +467,26 @@ export function createSkillsRoutes(deps) {
         const name = c.req.param("name");
         const slugCheck = skillNameSchema.safeParse(name);
         if (!slugCheck.success) {
-            return c.json({ error: "invalid_name", message: slugCheck.error.issues[0]?.message }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("skills.invalid_name", { field: "name", received: name })], { legacyFields: { message: slugCheck.error.issues[0]?.message } });
         }
         if (isBuiltinSlug(name)) {
-            return c.json({ error: "builtin_protected", name, message: "Built-in skills cannot be modified by this API" }, 403);
+            return respondWithAgentError(c, 403, [composeIssue("skills.builtin_protected", { field: "name", received: name })], {
+                legacyFields: {
+                    name,
+                    message: "Built-in skills cannot be modified by this API",
+                },
+            });
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const parsed = skillUpdateSchema.safeParse(parsedBody.body);
         if (!parsed.success) {
-            return c.json({ error: "validation_error", details: parsed.error.issues }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("skills.validation_error", { field: "body", received: parsedBody.body })], { legacyFields: { details: parsed.error.issues } });
         }
         const skillFile = safeSkillPath(userSkillsRoot, name);
         if (!skillFile || !existsSync(skillFile)) {
-            return c.json({ error: "not_found", name }, 404);
+            return respondWithAgentError(c, 404, [composeIssue("skills.not_found", { field: "name", received: name })], { legacyFields: { name } });
         }
         try {
             // Merge partial update with current content
@@ -449,7 +502,8 @@ export function createSkillsRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, name }, "Skill update failed");
-            return c.json({ error: "write_failed", message: toSafeErrorMessage(err) }, 500);
+            const message = toSafeErrorMessage(err);
+            return respondWithAgentError(c, 500, [composeIssue("skills.write_failed", { field: "write", received: message })], { legacyFields: { message } });
         }
         /* c8 ignore stop */
     });
@@ -458,14 +512,19 @@ export function createSkillsRoutes(deps) {
         const name = c.req.param("name");
         const slugCheck = skillNameSchema.safeParse(name);
         if (!slugCheck.success) {
-            return c.json({ error: "invalid_name", message: slugCheck.error.issues[0]?.message }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("skills.invalid_name", { field: "name", received: name })], { legacyFields: { message: slugCheck.error.issues[0]?.message } });
         }
         if (isBuiltinSlug(name)) {
-            return c.json({ error: "builtin_protected", name, message: "Built-in skills cannot be deleted by this API" }, 403);
+            return respondWithAgentError(c, 403, [composeIssue("skills.builtin_protected", { field: "name", received: name })], {
+                legacyFields: {
+                    name,
+                    message: "Built-in skills cannot be deleted by this API",
+                },
+            });
         }
         const skillFile = safeSkillPath(userSkillsRoot, name);
         if (!skillFile || !existsSync(skillFile)) {
-            return c.json({ error: "not_found", name }, 404);
+            return respondWithAgentError(c, 404, [composeIssue("skills.not_found", { field: "name", received: name })], { legacyFields: { name } });
         }
         try {
             // Remove the whole skill directory so we clean up any adjacent files
@@ -478,7 +537,8 @@ export function createSkillsRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, name }, "Skill delete failed");
-            return c.json({ error: "delete_failed", message: toSafeErrorMessage(err) }, 500);
+            const message = toSafeErrorMessage(err);
+            return respondWithAgentError(c, 500, [composeIssue("skills.delete_failed", { field: "delete", received: message })], { legacyFields: { message } });
         }
         /* c8 ignore stop */
     });
@@ -486,4 +546,3 @@ export function createSkillsRoutes(deps) {
 }
 // Exports for tests
 export { parseSkillFile, serializeSkillFile, safeSkillPath, listSkillsInRoot };
-//# sourceMappingURL=skills.js.map

package/dist/api/routes/sot-bindings.d.ts

@@ -3,7 +3,7 @@ import type Database from "better-sqlite3";
 import { type ManagementMdWriteLockManager } from "../../core/management-md-write-lock.js";
 import type { ApiDependencies } from "../server.js";
 /**
- * SoT bindings — Section A of `rules/management.md` (§9.5, §10.6).
+ * SoT bindings — Section A of `policies/management.md` (§9.5, §10.6).
  *
  * The list is small (typically ≤ DOMAINS.length) and PUT replace-
  * semantics (§10.6) is the only mutation surface. A single-binding
@@ -17,4 +17,3 @@ export interface SotBindingsRoutesDeps {
 }
 export declare function createSotBindingsRoutes(deps: SotBindingsRoutesDeps): Hono;
 export declare function buildSotBindingsRoutesDepsFromApi(deps: ApiDependencies, fallbackLockManager?: ManagementMdWriteLockManager): SotBindingsRoutesDeps;
-//# sourceMappingURL=sot-bindings.d.ts.map

package/dist/api/routes/sot-bindings.js

@@ -1,5 +1,6 @@
 import { Hono } from "hono";
 import { sotBindingsSchema, } from "@aitne/shared";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 import { readSotBindings, writeSotBindings, } from "../../db/sot-bindings-store.js";
 import { listManagedTasks } from "../../db/managed-tasks-store.js";
 import { readJsonBody } from "../json-body.js";
@@ -78,14 +79,26 @@ export function createSotBindingsRoutes(deps) {
     });
     // GET /sot-bindings/:category — single binding (404 when absent)
     app.get("/sot-bindings/:category", (c) => {
-        const category = c.req.param("category").trim();
+        const rawCategory = c.req.param("category");
+        const category = rawCategory.trim();
         if (!category) {
-            return c.json({ error: "invalid_category" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("sot_bindings.invalid_category", {
+                    field: "category",
+                    received: rawCategory,
+                }),
+            ]);
         }
         const items = readSotBindings(db);
         const item = items.find((b) => b.category === category);
-        if (!item)
-            return c.json({ error: "not_found" }, 404);
+        if (!item) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("sot_bindings.not_found", {
+                    field: "category",
+                    received: category,
+                }),
+            ]);
+        }
         return c.json({ item });
     });
     // PUT /sot-bindings — replace the entire list
@@ -104,11 +117,26 @@ export function createSotBindingsRoutes(deps) {
                 ? body.items
                 : null;
         if (candidate === null) {
-            return c.json({ error: "validation_error", message: "body must be an array or {items: [...]}" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("sot_bindings.validation_error", {
+                    field: "body",
+                    received: typeof body,
+                    expected: "array or { items: [...] }",
+                }),
+            ], {
+                legacyFields: {
+                    message: "body must be an array or {items: [...]}",
+                },
+            });
         }
         const parsed = sotBindingsSchema.safeParse(candidate);
         if (!parsed.success) {
-            return c.json({ error: "validation_error", details: parsed.error }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("sot_bindings.validation_error", {
+                    field: "items",
+                    received: candidate,
+                }),
+            ], { legacyFields: { details: parsed.error } });
         }
         // §13.3 — defense in depth: forbid duplicate categories. The Zod
         // schema accepts duplicates by default; the file render is keyed on
@@ -117,10 +145,12 @@ export function createSotBindingsRoutes(deps) {
         const seen = new Set();
         for (const row of parsed.data) {
             if (seen.has(row.category)) {
-                return c.json({
-                    error: "duplicate_category",
-                    category: row.category,
-                }, 400);
+                return respondWithAgentError(c, 400, [
+                    composeIssue("sot_bindings.duplicate_category", {
+                        field: "items[].category",
+                        received: row.category,
+                    }),
+                ], { legacyFields: { category: row.category } });
             }
             seen.add(row.category);
         }
@@ -131,7 +161,12 @@ export function createSotBindingsRoutes(deps) {
         }
         catch (err) {
             logger.error({ err }, "sot-bindings PUT write failed");
-            return c.json({ error: "internal_error" }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("sot_bindings.internal_error", {
+                    field: "<server>",
+                    received: "<db_write_failed>",
+                }),
+            ]);
         }
         recordAuditAction(db, { previous, next });
         let contextDir;
@@ -160,4 +195,3 @@ export function buildSotBindingsRoutesDepsFromApi(deps, fallbackLockManager) {
             new InMemoryManagementMdWriteLockManager(),
     };
 }
-//# sourceMappingURL=sot-bindings.js.map

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

@@ -83,4 +83,3 @@ export declare function createSSERoutes(deps: {
     attachmentStore?: AttachmentStore;
 }): Hono;
 export {};
-//# sourceMappingURL=sse.d.ts.map

package/dist/api/routes/sse.js

@@ -116,8 +116,13 @@ export function createSSERoutes(deps) {
             if (resolvedResume.sessionId && resolvedResume.valid && deps.rebindSessionChannel) {
                 deps.rebindSessionChannel(resolvedResume.sessionId, channelId);
             }
+            // Pass `client` so the adapter removes only THIS tab's SSE entry.
+            // Today each tab gets a unique channelId so it's equivalent to a
+            // full delete; this guards a future change that lets multiple
+            // tabs share a channelId (e.g. session-shared fan-out) from
+            // accidentally reaping every tab when one disconnects.
             stream.onAbort(() => {
-                adapter.unregisterClient(channelId);
+                adapter.unregisterClient(channelId, client);
             });
             // Keep alive with periodic pings until client disconnects
             while (!stream.aborted) {
@@ -375,4 +380,3 @@ export function createSSERoutes(deps) {
     });
     return app;
 }
-//# sourceMappingURL=sse.js.map

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

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

package/dist/api/routes/system.js

@@ -163,8 +163,21 @@ export function createSystemRoutes(deps) {
             //
             // `handleSecretChange` dispatches per-scope, so iterate over every
             // known scope rather than passing a single fake "factory-reset" name
-            // that falls through to the default/no-op branch.
-            const scopes = ["slack", "telegram", "discord", "notion", "github", "google"];
+            // that falls through to the default/no-op branch. The list mirrors
+            // every secret family in `SECRET_NAMES` that owns a live service /
+            // adapter the daemon holds in memory; `apple_calendar` is included
+            // so `services.appleCalendar` drops its iCloud-connected reference
+            // when the credentials blob gets wiped (otherwise the slot would
+            // stay populated until the operator restarts).
+            const scopes = [
+                "slack",
+                "telegram",
+                "discord",
+                "notion",
+                "github",
+                "google",
+                "apple_calendar",
+            ];
             const adapterReloadErrors = [];
             for (const scope of scopes) {
                 try {
@@ -204,4 +217,3 @@ export function createSystemRoutes(deps) {
     });
     return app;
 }
-//# sourceMappingURL=system.js.map

package/dist/api/routes/task-flows.d.ts

@@ -27,4 +27,3 @@
  */
 import { Hono } from "hono";
 export declare function createTaskFlowsRoutes(): Hono;
-//# sourceMappingURL=task-flows.d.ts.map

package/dist/api/routes/task-flows.js

@@ -152,4 +152,3 @@ export function createTaskFlowsRoutes() {
     });
     return app;
 }
-//# sourceMappingURL=task-flows.js.map

package/dist/api/routes/travel-bookings.d.ts

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

package/dist/api/routes/travel-bookings.js

@@ -1,4 +1,5 @@
 import { Hono } from "hono";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 export function createTravelBookingRoutes(deps) {
     const app = new Hono();
     const { db } = deps;
@@ -20,11 +21,11 @@ export function createTravelBookingRoutes(deps) {
         const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10), 1), 200);
         const validStatuses = ["upcoming", "completed", "cancelled", "all"];
         if (!validStatuses.includes(status)) {
-            return c.json({ error: "invalid_status", validStatuses }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("travel_bookings.invalid_status", { field: "status", received: status })], { legacyFields: { validStatuses } });
         }
         const validTypes = ["flight", "hotel", "restaurant", "train", "bus", "other"];
         if (type && !validTypes.includes(type)) {
-            return c.json({ error: "invalid_type", validTypes }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("travel_bookings.invalid_type", { field: "type", received: type })], { legacyFields: { validTypes } });
         }
         const conditions = [];
         const params = [];
@@ -103,19 +104,28 @@ export function createTravelBookingRoutes(deps) {
      * PATCH /travel-bookings/:id — update booking status or details.
      */
     app.patch("/travel-bookings/: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("travel_bookings.invalid_id", { field: "id", received: rawId }),
+            ]);
+        }
         let body;
         try {
             body = await c.req.json();
         }
         catch {
-            return c.json({ error: "invalid_json" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("travel_bookings.invalid_json", {
+                    field: "body",
+                    received: "<unparseable>",
+                }),
+            ]);
         }
         const validStatuses = ["upcoming", "completed", "cancelled"];
         if (body.status && !validStatuses.includes(body.status)) {
-            return c.json({ error: "invalid_status", valid: validStatuses }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("travel_bookings.invalid_status", { field: "status", received: body.status })], { legacyFields: { valid: validStatuses } });
         }
         const updates = [];
         const params = [];
@@ -128,15 +138,21 @@ export function createTravelBookingRoutes(deps) {
             params.push(body.destination);
         }
         if (updates.length === 0) {
-            return c.json({ error: "no_updates" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("travel_bookings.no_updates", {
+                    field: "body",
+                    received: body,
+                }),
+            ]);
         }
         params.push(id);
         const result = db.prepare(`UPDATE travel_bookings SET ${updates.join(", ")} WHERE id = ?`).run(...params);
         if (result.changes === 0) {
-            return c.json({ error: "not_found" }, 404);
+            return respondWithAgentError(c, 404, [
+                composeIssue("travel_bookings.not_found", { field: "id", received: id }),
+            ]);
         }
         return c.json({ ok: true, id });
     });
     return app;
 }
-//# sourceMappingURL=travel-bookings.js.map

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

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

package/dist/api/routes/triggers.js

@@ -98,4 +98,3 @@ export function createTriggerRoutes(deps) {
     });
     return app;
 }
-//# sourceMappingURL=triggers.js.map

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

@@ -47,4 +47,3 @@ export interface VoiceRoutesOptions {
 }
 export declare function createVoiceRoutes(deps: ApiDependencies, opts?: VoiceRoutesOptions): Hono;
 export {};
-//# sourceMappingURL=voice.d.ts.map

package/dist/api/routes/voice.js

@@ -528,4 +528,3 @@ export function createVoiceRoutes(deps, opts = {}) {
     });
     return app;
 }
-//# sourceMappingURL=voice.js.map

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

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