@jini-ai/daemon 0.3.7 → 0.5.0

package/dist/http/route-manifest.d.ts

@@ -0,0 +1,35 @@
+import type { RouteRegistration } from '@jini-ai/http-kit';
+/**
+ * Route families described by this manifest, keyed by the same feature id `@jini-ai/server`'s built-in
+ * feature catalog uses — so a host that enables features by name can look routes up by that same name.
+ */
+export declare const JINI_ROUTE_MANIFEST: Readonly<Record<string, readonly RouteRegistration[]>>;
+/**
+ * The routes one family mounts.
+ *
+ * @param family - A feature id, e.g. `'runs'`.
+ * @returns That family's registrations, or `undefined` when the family is not described by this
+ * manifest. The distinction matters: a caller building a proxy allow-list must treat `undefined` as
+ * "look it up yourself", never as "this family has no routes" — see this module's scope note.
+ * @complexity O(1).
+ * @overallScore 100/100
+ */
+export declare function routeFamilyManifest({ family }: {
+    readonly family: string;
+}, _optional?: Record<string, never>): readonly RouteRegistration[] | undefined;
+/**
+ * Every route across every family this manifest describes, de-duplicated.
+ *
+ * De-duplication is real rather than defensive: `health` intentionally mounts both `/health` and
+ * `/api/health` as separate routes, and a future family could legitimately share a path with another.
+ *
+ * @param families - Family ids to include. Unknown ids contribute nothing (rather than throwing), so a
+ * caller can pass its enabled-feature list verbatim without pre-filtering it.
+ * @returns One entry per distinct `METHOD PATH`, in first-seen order.
+ * @complexity O(n) in the total routes across the named families.
+ * @overallScore 100/100
+ */
+export declare function manifestRoutesForFamilies({ families }: {
+    readonly families: readonly string[];
+}, _optional?: Record<string, never>): readonly RouteRegistration[];
+//# sourceMappingURL=route-manifest.d.ts.map

package/dist/http/route-manifest.js

@@ -0,0 +1,103 @@
+/**
+ * @module route-manifest
+ *
+ * Which `{method, path}` pairs each route family mounts, as inert data a caller can read *without*
+ * mounting anything.
+ *
+ * **The problem this solves.** A host that puts a reverse proxy in front of a Jini daemon in another
+ * process has to know that daemon's route list to forward anything. With no published inventory, the
+ * only way to build one is to copy path strings by hand — and a hand-copied list silently falls behind
+ * the moment a family gains a route. That has already happened at least once in a real consumer: a
+ * proxy shipped without `GET /api/runs` and the daemon's list endpoint was simply unreachable, 404-ing
+ * at the host's own router with nothing to indicate the host was the cause.
+ *
+ * **Why this file cannot itself drift.** It declares no method or path literals. Every entry is derived
+ * from the very `JsonRouteSpec` constant the family's `register*Routes` function mounts, so a spec's
+ * path change moves the manifest with it, automatically. The single exception is the SSE run-event
+ * route, which is registered with a bare `app.get` rather than a spec — and it contributes the
+ * already-exported `RUN_EVENTS_ROUTE_PATH` constant rather than a copy of it.
+ *
+ * That leaves exactly one failure mode: a family gains a route and nobody adds it *here*. The paired
+ * test (`__tests__/route-manifest.test.ts`) closes that by mounting each declared family's real
+ * registrar onto a recording app and asserting the manifest matches what actually registered — so a
+ * missing entry fails a test rather than reaching a consumer.
+ *
+ * **Scope, stated honestly: this covers the families a sidecar consumer proxies**, not all 19 the
+ * package can mount. {@link routeFamilyManifest} returns `undefined` for anything undeclared rather
+ * than an empty list, so "not described here" is distinguishable from "has no routes" — a proxy must
+ * never conclude a family is empty when it is merely undocumented. Adding a family is a matter of
+ * listing its exported specs below; the test then holds it correct.
+ */
+import { agentListRoute, agentRescanRoute } from './agents.js';
+import { delegatedToolExecuteRoute } from './delegated-tools.js';
+import { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, versionInfoRoute, } from './health.js';
+import { RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
+import { toolCatalogDescribeRoute, toolCatalogSearchRoute } from './tool-catalog.js';
+/**
+ * Projects route specs onto `RouteRegistration`s, upper-casing the method so entries compare directly
+ * against {@link getRouteRegistrationInventory}'s output.
+ *
+ * @param specs - Route specs, passed by reference so no path literal is ever restated.
+ * @returns One registration per spec, in argument order.
+ * @complexity O(n) in the number of specs.
+ * @overallScore 100/100
+ */
+function fromSpecs(...specs) {
+    return specs.map((spec) => ({ method: spec.method.toUpperCase(), path: spec.path }));
+}
+/**
+ * Route families described by this manifest, keyed by the same feature id `@jini-ai/server`'s built-in
+ * feature catalog uses — so a host that enables features by name can look routes up by that same name.
+ */
+export const JINI_ROUTE_MANIFEST = {
+    health: fromSpecs(healthRoute, apiHealthRoute, readyRoute, apiReadyRoute, versionInfoRoute, apiVersionInfoRoute),
+    runs: [
+        ...fromSpecs(runStartRoute, runListRoute, runStatusRoute, runCancelRoute),
+        // Registered with a bare `app.get` rather than a route spec (by `registerRunRoutes` itself), so
+        // it contributes its exported path constant instead of a copied literal.
+        { method: 'GET', path: RUN_EVENTS_ROUTE_PATH },
+    ],
+    agents: fromSpecs(agentListRoute, agentRescanRoute),
+    toolCatalog: fromSpecs(toolCatalogSearchRoute, toolCatalogDescribeRoute),
+    delegatedToolCalls: fromSpecs(delegatedToolExecuteRoute),
+};
+/**
+ * The routes one family mounts.
+ *
+ * @param family - A feature id, e.g. `'runs'`.
+ * @returns That family's registrations, or `undefined` when the family is not described by this
+ * manifest. The distinction matters: a caller building a proxy allow-list must treat `undefined` as
+ * "look it up yourself", never as "this family has no routes" — see this module's scope note.
+ * @complexity O(1).
+ * @overallScore 100/100
+ */
+export function routeFamilyManifest({ family }, _optional = {}) {
+    return JINI_ROUTE_MANIFEST[family];
+}
+/**
+ * Every route across every family this manifest describes, de-duplicated.
+ *
+ * De-duplication is real rather than defensive: `health` intentionally mounts both `/health` and
+ * `/api/health` as separate routes, and a future family could legitimately share a path with another.
+ *
+ * @param families - Family ids to include. Unknown ids contribute nothing (rather than throwing), so a
+ * caller can pass its enabled-feature list verbatim without pre-filtering it.
+ * @returns One entry per distinct `METHOD PATH`, in first-seen order.
+ * @complexity O(n) in the total routes across the named families.
+ * @overallScore 100/100
+ */
+export function manifestRoutesForFamilies({ families }, _optional = {}) {
+    const seen = new Set();
+    const routes = [];
+    for (const family of families) {
+        for (const route of JINI_ROUTE_MANIFEST[family] ?? []) {
+            const key = `${route.method} ${route.path}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            routes.push(route);
+        }
+    }
+    return routes;
+}
+//# sourceMappingURL=route-manifest.js.map

package/dist/http/routines.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @module routines
+ *
+ * Routine CRUD + run-history HTTP routes: `GET/POST /api/routines`, `GET/PATCH/DELETE
+ * /api/routines/:id`, `POST /api/routines/:id/run`, `GET /api/routines/:id/runs`. Calls into the
+ * `RoutineStore`/`RoutineService`-shaped ports `@jini-ai/daemon` ships (see that package's
+ * `routines/` module — `routine-store.ts` for the CRUD+history port, `scheduler.ts` for the
+ * scheduling engine) the same way `runs.ts` calls into `RunLifecycle` — no business logic lives
+ * in this file itself.
+ *
+ * Ported from OD's `apps/daemon/src/routes/routine.ts` (348 lines, `refactor/web-memory-slice`
+ * branch) per the decisions in `ADS-memory/reports/proposals/
+ * PROP-http-route-packs-automation-routines-2026-07-21.md` (Finding 2). That proposal identified
+ * two separable gaps blocking this route pack: (1) no scheduler existed anywhere in this repo —
+ * closed by porting `routines.ts` into `@jini-ai/daemon/src/routines/scheduler.ts` this same pass;
+ * (2) no `RoutineStore` persistence port existed for the CRUD side — closed by
+ * `@jini-ai/daemon/src/routines/routine-store.ts`, designed the same way `EventLog` is designed.
+ * This file is the third piece: the actual HTTP routes, now that both ports exist.
+ *
+ * **Confirmed bug fixed while porting** (per the proposal's own finding, not carried forward):
+ * OD's `GET /api/routines/:id`, `DELETE /api/routines/:id`, and `GET /api/routines/:id/runs` (OD
+ * source lines 236/268/292) had no try/catch, unlike every sibling handler in the same file. This
+ * port does not reproduce that gap — but not via a per-route try/catch either: every route here
+ * is mounted through `adapter.ts`'s `mountJsonRoute`, whose own top-level try/catch already wraps
+ * every route's `parse`/`handle` invocation (the same mechanism `runs.ts`/`memory.ts` rely on),
+ * so the bug is structurally impossible to reintroduce rather than merely patched at three call
+ * sites.
+ *
+ * **Deliberately NOT ported** (see the proposal's Finding 1 and the "built-in template scoping"
+ * decision it required a human call on):
+ * - `GET /api/automation-templates` / `GET /api/automation-templates/:id` — these depend on
+ *   `automation-templates.ts`, which is not ported (see below); none of the routine CRUD/run-now/
+ *   run-history routes below need it to function.
+ * - `POST /api/routines/:id/runs/:runId/crystallize` — depends on `ingestAutomationSource`
+ *   (`automation-ingestions.ts`), explicitly scoped by the proposal as "a dedicated follow-up
+ *   task the same size and shape as `@jini-ai/memory`'s own original port," not attempted here.
+ * - `automation-templates.ts` itself, including its CRUD-adjacent lookup machinery: the decision
+ *   already made for this pass is to ship **zero built-in automation templates** (matching this
+ *   repo's established precedent of keeping product-authored content host-owned — `@jini-ai/memory`'s
+ *   prompt-composition, `@jini-ai/deploy`'s config-path resolution, etc.) and, since no route in this
+ *   file needs any part of that module to function, none of it — content or generic shape — is
+ *   ported this pass.
+ * - `automation-proposals.ts` / `automation-ingestions.ts` — untouched, per the proposal's Finding
+ *   1 explicit scoping and this task's brief.
+ *
+ * **Design note — why `target.mode === 'reuse'` project-existence checking is optional, injected
+ * DI, not a hard dependency**: OD's original unconditionally called `getProject(db, projectId)`
+ * to validate a reuse target. This module has no project concept of its own (matching
+ * `active-context.ts`'s `resolveResource` precedent for the same category of coupling), so
+ * `RoutineHttpDeps.projectExists` is an optional injected predicate: a host that has a project
+ * store supplies it and reuse targets are validated against it exactly like OD did; a host with
+ * no such concept (or that wants to defer the check) can omit it, and reuse targets are accepted
+ * without existence-checking rather than forcing every consumer to fabricate one.
+ *
+ * **Design note — why `POST /api/routines/:id/run`'s `run` field can be `null` even on success**:
+ * `RoutineStore` deliberately does not record runs (see `routine-store.ts`'s module doc: run
+ * *writing* stays the scheduler's own separately-injected `RoutinePersistence` concern, matching
+ * OD's own architectural split between the two). This route calls `store.getLatestRun(id)` after
+ * `scheduler.runNow(id)` resolves — accurate only if a host has bridged the scheduler's
+ * `RoutinePersistence.insertRun`/`updateRun` writes into the same store instance (documented,
+ * host-level integration wiring, out of this port's scope, the same way `runs.ts`'s `onStarted`
+ * driver is host-supplied). `projectId`/`conversationId`/`agentRunId` on the response always
+ * reflect the real, just-started run regardless of that wiring, since those come directly from
+ * `scheduler.runNow`'s own return value.
+ */
+import type { Express } from 'express';
+import { type Routine, type RoutineCreateInput, type RoutineRun, type RoutineService, type RoutineStore, type RoutineUpdateInput } from '../index.js';
+import { type AdapterContext } from '@jini-ai/http-kit';
+/** The scheduler surface these routes need — a structural subset of `RoutineService`, matching OD's own `RoutineRoutesService` narrowing (`Pick<RoutineService, 'nextRunAt' | 'rescheduleOne' | 'runNow' | 'unschedule'>`). Wiring a real `RoutineService` in satisfies this with zero adapter code. */
+export type RoutineScheduler = Pick<RoutineService, 'nextRunAt' | 'rescheduleOne' | 'runNow' | 'unschedule'>;
+export interface RoutineHttpDeps {
+    readonly store: RoutineStore;
+    readonly scheduler: RoutineScheduler;
+    /** Validates a `target: {mode: 'reuse', projectId}`'s `projectId` before create/update accept it. Omit to skip existence-checking entirely — see this module's doc comment. */
+    readonly projectExists?: ({ projectId }: {
+        projectId: string;
+    }) => boolean | Promise<boolean>;
+}
+interface RoutineUpdateRequest {
+    readonly id: string;
+    readonly patch: RoutineUpdateInput;
+}
+interface RoutineRunsQuery {
+    readonly id: string;
+    readonly limit: number;
+}
+export interface RoutineListResponse {
+    readonly routines: readonly Routine[];
+}
+export declare const routineListRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, RoutineListResponse, RoutineHttpDeps>;
+export interface RoutineResponse {
+    readonly routine: Routine;
+}
+export declare const routineCreateRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineCreateInput, RoutineResponse, RoutineHttpDeps>;
+export declare const routineGetRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineResponse, RoutineHttpDeps>;
+export declare const routineUpdateRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineUpdateRequest, RoutineResponse, RoutineHttpDeps>;
+export interface RoutineDeleteResponse {
+    readonly ok: true;
+}
+export declare const routineDeleteRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineDeleteResponse, RoutineHttpDeps>;
+export interface RoutineRunNowResponse {
+    readonly routine: Routine | null;
+    readonly run: RoutineRun | null;
+    readonly projectId: string;
+    readonly conversationId: string;
+    readonly agentRunId: string;
+}
+export declare const routineRunNowRoute: import("@jini-ai/http-kit").JsonRouteSpec<string, RoutineRunNowResponse, RoutineHttpDeps>;
+export interface RoutineRunsResponse {
+    readonly runs: readonly RoutineRun[];
+}
+export declare const routineRunsListRoute: import("@jini-ai/http-kit").JsonRouteSpec<RoutineRunsQuery, RoutineRunsResponse, RoutineHttpDeps>;
+/** Mounts every routine route on `app`. A pack's `http(app, services)` calls this directly. */
+export declare function registerRoutineRoutes({ app, deps, adapter }: {
+    readonly app: Express;
+    readonly deps: RoutineHttpDeps;
+    readonly adapter: AdapterContext;
+}, _optional?: Record<string, never>): void;
+export {};
+//# sourceMappingURL=routines.d.ts.map

package/dist/http/routines.js

@@ -0,0 +1,298 @@
+import { validateSchedule, validateTarget, } from '../index.js';
+import { createApiError } from '@jini-ai/protocol';
+import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
+import { validationError } from '@jini-ai/http-kit';
+import { err, ok } from '@jini-ai/http-kit';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Overlays the scheduler's live `nextRunAt` onto a routine fetched from the store — `RoutineStore` itself has no scheduler knowledge (see `routine-store.ts`'s module doc), matching OD's own `routineFromDb` two-step (fetch, then overlay `routineService.nextRunAt`). */
+function attachNextRunAt(routine, scheduler) {
+    return { ...routine, nextRunAt: scheduler.nextRunAt({ routineId: routine.id })?.getTime() ?? null };
+}
+async function checkTargetProjectExists(target, deps) {
+    if (target.mode !== 'reuse' || !deps.projectExists)
+        return null;
+    const exists = await deps.projectExists({ projectId: target.projectId });
+    return exists ? null : createApiError({ code: 'NOT_FOUND', message: `target project ${target.projectId} not found` });
+}
+function parseRoutineId(input) {
+    const id = input.params.id;
+    return typeof id === 'string' && id.length > 0 ? ok({ value: id }) : err({ error: validationError({ message: 'id must be a non-empty path parameter' }) });
+}
+function parseNonEmptyString(value, field) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return err({ error: validationError({ message: `${field} is required` }, { issues: [{ path: field, message: 'required non-empty string' }] }) });
+    }
+    return ok({ value: value.trim() });
+}
+/** Present-but-non-string/empty is rejected; absent (`undefined`) or explicit `null` are both accepted (clearing the field on update). */
+function parseOptionalNullableString(body, field) {
+    const value = body[field];
+    if (value === undefined)
+        return ok({ value: undefined });
+    if (value === null)
+        return ok({ value: null });
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return err({ error: validationError({ message: `${field} must be a non-empty string or null when provided` }) });
+    }
+    return ok({ value });
+}
+function parseSchedule(value) {
+    try {
+        validateSchedule({ schedule: value });
+    }
+    catch (error) {
+        return err({ error: validationError({ message: errorMessage(error) }) });
+    }
+    return ok({ value: value });
+}
+function parseTarget(value) {
+    try {
+        validateTarget({ target: value });
+    }
+    catch (error) {
+        return err({ error: validationError({ message: errorMessage(error) }) });
+    }
+    return ok({ value: value });
+}
+/** Validates and de-duplicates one `context.*` array field, trimming entries and dropping blanks — mirrors OD's `cleanStringList`. */
+function cleanStringList(value, field) {
+    if (!Array.isArray(value))
+        return err({ error: validationError({ message: `${field} must be an array` }) });
+    const out = [];
+    const seen = new Set();
+    for (const item of value) {
+        if (typeof item !== 'string')
+            return err({ error: validationError({ message: `${field} must contain strings` }) });
+        const trimmed = item.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return ok({ value: out });
+}
+const CONTEXT_FIELDS = ['skillIds', 'pluginIds', 'mcpServerIds', 'connectorIds'];
+/** Mirrors OD's `normalizeRoutineContext`: an explicitly-empty array for a field is dropped entirely (not kept as `[]`) so a routine's stored context only ever carries fields that actually scope something. */
+function parseContextSelection(value) {
+    if (value === undefined || value === null)
+        return ok({ value: {} });
+    if (!isRecord(value))
+        return err({ error: validationError({ message: 'context must be an object' }) });
+    const context = {};
+    for (const field of CONTEXT_FIELDS) {
+        const raw = value[field];
+        if (raw === undefined)
+            continue;
+        const cleaned = cleanStringList(raw, `context.${field}`);
+        if (!cleaned.ok)
+            return cleaned;
+        if (cleaned.value.length > 0)
+            context[field] = cleaned.value;
+    }
+    return ok({ value: context });
+}
+function parseRoutineCreate(input) {
+    if (!isRecord(input.body))
+        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+    const name = parseNonEmptyString(input.body.name, 'name');
+    if (!name.ok)
+        return name;
+    const prompt = parseNonEmptyString(input.body.prompt, 'prompt');
+    if (!prompt.ok)
+        return prompt;
+    const schedule = parseSchedule(input.body.schedule);
+    if (!schedule.ok)
+        return schedule;
+    const target = parseTarget(input.body.target);
+    if (!target.ok)
+        return target;
+    const skillId = parseOptionalNullableString(input.body, 'skillId');
+    if (!skillId.ok)
+        return skillId;
+    const agentId = parseOptionalNullableString(input.body, 'agentId');
+    if (!agentId.ok)
+        return agentId;
+    const context = parseContextSelection(input.body.context);
+    if (!context.ok)
+        return context;
+    const enabled = input.body.enabled;
+    if (enabled !== undefined && typeof enabled !== 'boolean') {
+        return err({ error: validationError({ message: 'enabled must be a boolean when provided' }) });
+    }
+    return ok({
+        value: {
+            name: name.value,
+            prompt: prompt.value,
+            schedule: schedule.value,
+            target: target.value,
+            ...(skillId.value !== undefined ? { skillId: skillId.value } : {}),
+            ...(agentId.value !== undefined ? { agentId: agentId.value } : {}),
+            context: context.value,
+            ...(enabled !== undefined ? { enabled } : {}),
+        }
+    });
+}
+function parseRoutineUpdate(input) {
+    const idResult = parseRoutineId(input);
+    if (!idResult.ok)
+        return idResult;
+    if (!isRecord(input.body))
+        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+    const body = input.body;
+    // `RoutineUpdateInput`'s fields are `readonly` (an immutable port-input contract) — built here
+    // as a mutable local shape field-by-field, then handed back as that readonly type, which is a
+    // safe widening (mutable -> readonly), not the reverse.
+    const patch = {};
+    if (body.name !== undefined) {
+        const name = parseNonEmptyString(body.name, 'name');
+        if (!name.ok)
+            return name;
+        patch.name = name.value;
+    }
+    if (body.prompt !== undefined) {
+        const prompt = parseNonEmptyString(body.prompt, 'prompt');
+        if (!prompt.ok)
+            return prompt;
+        patch.prompt = prompt.value;
+    }
+    if (body.schedule !== undefined) {
+        const schedule = parseSchedule(body.schedule);
+        if (!schedule.ok)
+            return schedule;
+        patch.schedule = schedule.value;
+    }
+    if (body.target !== undefined) {
+        const target = parseTarget(body.target);
+        if (!target.ok)
+            return target;
+        patch.target = target.value;
+    }
+    if (body.skillId !== undefined) {
+        const skillId = parseOptionalNullableString(body, 'skillId');
+        if (!skillId.ok)
+            return skillId;
+        patch.skillId = skillId.value ?? null;
+    }
+    if (body.agentId !== undefined) {
+        const agentId = parseOptionalNullableString(body, 'agentId');
+        if (!agentId.ok)
+            return agentId;
+        patch.agentId = agentId.value ?? null;
+    }
+    if (body.context !== undefined) {
+        const context = parseContextSelection(body.context);
+        if (!context.ok)
+            return context;
+        patch.context = context.value;
+    }
+    if (body.enabled !== undefined) {
+        if (typeof body.enabled !== 'boolean')
+            return err({ error: validationError({ message: 'enabled must be a boolean when provided' }) });
+        patch.enabled = body.enabled;
+    }
+    return ok({ value: { id: idResult.value, patch } });
+}
+function parseRoutineRunsQuery(input) {
+    const idResult = parseRoutineId(input);
+    if (!idResult.ok)
+        return idResult;
+    const raw = input.query.limit;
+    const rawValue = Array.isArray(raw) ? raw[0] : raw;
+    // Retains OD's ceiling/floor and fallback for NaN/0/absent. Unlike its `|| 20` expression,
+    // explicitly fall back for negatives too: a truthy negative must not defeat the documented default.
+    const parsed = Number(rawValue);
+    const numeric = parsed > 0 ? parsed : 20;
+    const limit = Math.min(100, Math.max(1, numeric));
+    return ok({ value: { id: idResult.value, limit } });
+}
+export const routineListRoute = defineJsonRoute({
+    method: 'get', path: '/api/routines', parse: () => ok({ value: undefined }), handle: async ({ input: _input, deps }) => {
+        const routines = await deps.store.list();
+        return ok({ value: { routines: routines.map((routine) => attachNextRunAt(routine, deps.scheduler)) } });
+    }
+});
+export const routineCreateRoute = defineJsonRoute({
+    method: 'post', path: '/api/routines', parse: parseRoutineCreate, handle: async ({ input, deps }) => {
+        const targetError = await checkTargetProjectExists(input.target, deps);
+        if (targetError)
+            return err({ error: targetError });
+        const routine = await deps.store.create(input);
+        deps.scheduler.rescheduleOne({ routineId: routine.id });
+        return ok({ value: { routine: attachNextRunAt(routine, deps.scheduler) } });
+    }
+}, { requireSameOrigin: true, successStatus: 201 });
+// ---------------------------------------------------------------------------
+// GET/PATCH/DELETE /api/routines/:id
+// ---------------------------------------------------------------------------
+export const routineGetRoute = defineJsonRoute({
+    method: 'get', path: '/api/routines/:id', parse: parseRoutineId, handle: async ({ input: id, deps }) => {
+        const routine = await deps.store.get({ id });
+        return routine === null
+            ? err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) })
+            : ok({ value: { routine: attachNextRunAt(routine, deps.scheduler) } });
+    }
+});
+export const routineUpdateRoute = defineJsonRoute({
+    method: 'patch', path: '/api/routines/:id', parse: parseRoutineUpdate, handle: async ({ input: { id, patch }, deps }) => {
+        if (patch.target !== undefined) {
+            const targetError = await checkTargetProjectExists(patch.target, deps);
+            if (targetError)
+                return err({ error: targetError });
+        }
+        const routine = await deps.store.update({ id, patch });
+        if (routine === null)
+            return err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) });
+        deps.scheduler.rescheduleOne({ routineId: id });
+        return ok({ value: { routine: attachNextRunAt(routine, deps.scheduler) } });
+    }
+}, { requireSameOrigin: true });
+export const routineDeleteRoute = defineJsonRoute({
+    method: 'delete', path: '/api/routines/:id', parse: parseRoutineId, handle: async ({ input: id, deps }) => {
+        deps.scheduler.unschedule({ routineId: id });
+        const removed = await deps.store.delete({ id });
+        return removed ? ok({ value: { ok: true } }) : err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) });
+    }
+}, { requireSameOrigin: true });
+export const routineRunNowRoute = defineJsonRoute({
+    method: 'post', path: '/api/routines/:id/run', parse: parseRoutineId, handle: async ({ input: id, deps }) => {
+        const existing = await deps.store.get({ id });
+        if (existing === null)
+            return err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) });
+        const started = await deps.scheduler.runNow({ routineId: id });
+        const [routine, run] = await Promise.all([deps.store.get({ id }), deps.store.getLatestRun({ routineId: id })]);
+        return ok({
+            value: {
+                routine: routine ? attachNextRunAt(routine, deps.scheduler) : null,
+                run,
+                projectId: started.projectId,
+                conversationId: started.conversationId,
+                agentRunId: started.agentRunId,
+            }
+        });
+    }
+}, { requireSameOrigin: true, successStatus: 202 });
+export const routineRunsListRoute = defineJsonRoute({
+    method: 'get', path: '/api/routines/:id/runs', parse: parseRoutineRunsQuery, handle: async ({ input: { id, limit }, deps }) => {
+        const existing = await deps.store.get({ id });
+        if (existing === null)
+            return err({ error: createApiError({ code: 'NOT_FOUND', message: 'routine not found' }) });
+        const runs = await deps.store.listRuns({ routineId: id, limit });
+        return ok({ value: { runs } });
+    }
+});
+/** Mounts every routine route on `app`. A pack's `http(app, services)` calls this directly. */
+export function registerRoutineRoutes({ app, deps, adapter }, _optional = {}) {
+    mountJsonRoute({ app, spec: routineListRoute, deps, adapter });
+    mountJsonRoute({ app, spec: routineCreateRoute, deps, adapter });
+    mountJsonRoute({ app, spec: routineGetRoute, deps, adapter });
+    mountJsonRoute({ app, spec: routineUpdateRoute, deps, adapter });
+    mountJsonRoute({ app, spec: routineDeleteRoute, deps, adapter });
+    mountJsonRoute({ app, spec: routineRunNowRoute, deps, adapter });
+    mountJsonRoute({ app, spec: routineRunsListRoute, deps, adapter });
+}
+//# sourceMappingURL=routines.js.map

package/dist/http/run-credentials.d.ts

@@ -0,0 +1,73 @@
+import type { RequestHandler } from 'express';
+/** Structural result of the daemon's transport-independent credential/ownership policies. */
+export type RunAccessDecision = {
+    readonly allowed: true;
+    readonly principalHeader?: {
+        readonly name: string;
+        readonly value: string;
+    };
+} | {
+    readonly allowed: false;
+    readonly status: 400 | 401 | 403 | 404 | 503;
+    readonly body: unknown;
+};
+export interface DaemonAuthRequired {
+    readonly authorizationHeaderName: string;
+    /** Bind the daemon policy's environment, crypto, route and credential ports at composition. */
+    readonly authorize: (required: {
+        request: {
+            method: string;
+            path: string;
+            headers: Readonly<Record<string, string | undefined>>;
+            body?: unknown;
+        };
+    }, optional: {
+        validateDelegatedRunId: boolean;
+    }) => RunAccessDecision;
+}
+/** Mount before JSON parsing, then again on delegated calls after parsing with body validation.
+ * Only the allowed policy result may replace the principal header; trusted proxy headers remain intact.
+ * Policy exceptions go to Express's error boundary. No request body is accessed in the first gate.
+ * @complexity O(1) adapter work, excluding the injected authorization policy.
+ */
+export declare function createDaemonAuthMiddleware({ authorize, authorizationHeaderName }: DaemonAuthRequired, { validateDelegatedRunId }?: {
+    validateDelegatedRunId?: boolean;
+}): RequestHandler;
+export interface RunOwnershipRequired {
+    readonly principalHeaderName: string;
+    readonly isEventStream: (required: {
+        path: string;
+    }) => boolean;
+    /** Bind authorizeRunOwnership's registry, run lookup and header policy at composition. */
+    readonly authorize: (required: {
+        runId: string | undefined;
+        principalId: string | undefined;
+        eventStream: boolean;
+    }) => Promise<RunAccessDecision>;
+}
+/** Mount after authentication on routes with a runId parameter. Denial envelopes pass through intact.
+ * @complexity O(1) adapter work plus the injected ownership lookup; no storage or identity defaults.
+ */
+export declare function createRunOwnershipMiddleware({ authorize, principalHeaderName, isEventStream }: RunOwnershipRequired): RequestHandler;
+export interface OwnedRunListRequired<Run> {
+    readonly principalHeaderName: string;
+    readonly listRuns: (required: Record<string, never>, optional: {
+        contextRef?: string;
+    }) => Promise<readonly Run[]>;
+    /** Bind listOwnedRuns's registry and principal-header policy at composition. */
+    readonly filterOwnedRuns: (required: {
+        runs: readonly Run[];
+        principalId: string | undefined;
+    }) => {
+        allowed: true;
+        runs: Run[];
+    } | Extract<RunAccessDecision, {
+        allowed: false;
+    }>;
+}
+/** List only the authenticated principal's runs, after the host's context filter.
+ * Missing principals receive the existing 401 envelope before the list port is called.
+ * @complexity O(n) policy filtering for n listed runs; O(1) adapter space excluding results.
+ */
+export declare function createOwnedRunListHandler<Run>({ listRuns, filterOwnedRuns, principalHeaderName }: OwnedRunListRequired<Run>): RequestHandler;
+//# sourceMappingURL=run-credentials.d.ts.map