@aitne/daemon 0.1.7 → 0.1.9

package/dist/api/routes/schedule-validation.js

@@ -0,0 +1,152 @@
+import { BACKEND_IDS, isBackendId, } from "@aitne/shared";
+import { getModelsForBackend } from "../../core/backends/model-registry.js";
+const LEGACY_ALIAS_TIERS = {
+    sonnet: "medium",
+    opus: "high",
+};
+/**
+ * Build a snapshot of `MODEL_REGISTRY`. Used by:
+ *   - `GET /api/schedule/options` — returned verbatim under `models` +
+ *     `modelAliases` keys (§4.4).
+ *   - `validateModelToken` — fed in as the second argument so the unknown
+ *     branch can cite valid alternatives without re-walking the registry.
+ *
+ * Entries appear in registry declaration order; callers that need a
+ * sorted view should re-sort. Deprecated entries are kept in the snapshot
+ * (so the dashboard can still surface them) but excluded from the error
+ * envelope's `validValues` payload (so the agent's retry can't loop on a
+ * model the registry would have warned about) — see
+ * `simplifyForUnknownPayload`.
+ */
+export function snapshotModelRegistry() {
+    const models = {};
+    for (const backendId of BACKEND_IDS) {
+        models[backendId] = getModelsForBackend(backendId).map((model) => ({
+            id: model.modelId,
+            tier: model.tier,
+            deprecated: Boolean(model.deprecated),
+        }));
+    }
+    return {
+        modelAliases: { ...LEGACY_ALIAS_TIERS },
+        models,
+    };
+}
+/**
+ * Project the rich snapshot into the simpler shape the error envelope
+ * cites. Deprecated entries are stripped so an LLM retry doesn't
+ * immediately pick a model the registry is about to remove.
+ */
+function simplifyForUnknownPayload(snapshot) {
+    const models = {};
+    for (const backendId of BACKEND_IDS) {
+        models[backendId] = snapshot.models[backendId]
+            .filter((m) => !m.deprecated)
+            .map((m) => m.id);
+    }
+    return {
+        aliases: ["sonnet", "opus"],
+        models,
+    };
+}
+/**
+ * Locate every snapshot entry matching `modelId` under `backendId`.
+ * Snapshot-driven so the ambiguous branch is testable without mutating
+ * the live `MODEL_REGISTRY`.
+ */
+function findInSnapshot(snapshot, backendId, modelId) {
+    return snapshot.models[backendId].find((m) => m.id === modelId);
+}
+/**
+ * Resolve a caller-supplied `model` token to one of four outcomes. See
+ * `ValidateModelResult` for the contract.
+ *
+ * Resolution order (per SCHEDULE_API_REDESIGN_PLAN.md §4.3):
+ *   1. Legacy alias ("sonnet" / "opus") → kind:"alias".
+ *   2. Composite form "<backendId>/<modelId>" — opt-in disambiguator.
+ *      Only honored when the prefix is exactly one of `BACKEND_IDS`. A
+ *      composite token that fails to resolve falls through to "unknown"
+ *      (not "ambiguous"); the caller named a specific backend, so an
+ *      ambiguous match is impossible by construction. A slash-bearing
+ *      token whose prefix is NOT a backend id falls through to the
+ *      cross-backend scan — opencode model ids like
+ *      `anthropic/claude-opus-4-8` would otherwise be unreachable.
+ *   3. Cross-backend exact match in the snapshot:
+ *        - exactly one match → kind:"model"
+ *        - multiple matches  → kind:"ambiguous" (future-proof; today
+ *          unreachable because `claude-opus-4-8` and opencode's
+ *          `anthropic/claude-opus-4-8` differ — but the registry is
+ *          editable and a future entry could collide).
+ *   4. No match → kind:"unknown" with the simplified validValues payload.
+ *
+ * Pure — relies only on the snapshot argument.
+ */
+export function validateModelToken(token, snapshot) {
+    // 1. Legacy alias path.
+    if (token === "sonnet" || token === "opus") {
+        return { kind: "alias", tierToken: snapshot.modelAliases[token] };
+    }
+    // 2. Composite-form disambiguation.
+    const firstSlash = token.indexOf("/");
+    if (firstSlash > 0) {
+        const prefix = token.slice(0, firstSlash);
+        const rest = token.slice(firstSlash + 1);
+        if (isBackendId(prefix) && rest.length > 0) {
+            const found = findInSnapshot(snapshot, prefix, rest);
+            if (found) {
+                return {
+                    kind: "model",
+                    backendId: prefix,
+                    modelId: rest,
+                    deprecated: found.deprecated,
+                };
+            }
+            // Composite prefix named a real backend but pointed at an
+            // unregistered model — surface as unknown (the caller already
+            // picked a backend; ambiguous is impossible).
+            return { kind: "unknown", validValues: simplifyForUnknownPayload(snapshot) };
+        }
+        // Prefix did not match a backend id (e.g. "anthropic/claude-opus-4-8"
+        // intended for opencode but lacking the explicit "opencode/" prefix).
+        // Fall through to the cross-backend scan — `anthropic/...` IS a
+        // registered opencode modelId, so step 3 still recognises it.
+    }
+    // 3. Cross-backend exact match scan.
+    const matches = [];
+    for (const backendId of BACKEND_IDS) {
+        const found = findInSnapshot(snapshot, backendId, token);
+        if (found) {
+            matches.push({
+                backendId,
+                modelId: token,
+                deprecated: found.deprecated,
+            });
+        }
+    }
+    if (matches.length === 1) {
+        const only = matches[0];
+        return {
+            kind: "model",
+            backendId: only.backendId,
+            modelId: only.modelId,
+            deprecated: only.deprecated,
+        };
+    }
+    if (matches.length > 1) {
+        const lite = matches.map(({ backendId, modelId }) => ({ backendId, modelId }));
+        const backendList = matches.map((m) => m.backendId).join(", ");
+        const first = matches[0];
+        return {
+            kind: "ambiguous",
+            matches: lite,
+            validValues: {
+                matches: lite,
+                hint: `Model id matches multiple backends (${backendList}). ` +
+                    `Specify '<backendId>/<modelId>' form, e.g. ` +
+                    `'${first.backendId}/${first.modelId}'.`,
+            },
+        };
+    }
+    // 4. Unknown.
+    return { kind: "unknown", validValues: simplifyForUnknownPayload(snapshot) };
+}

package/dist/api/routes/setup-migrate.d.ts

@@ -79,4 +79,3 @@ export declare function sweepExpiredMigrationBackups(db: Database.Database, opts
     swept: number;
     errors: number;
 };
-//# sourceMappingURL=setup-migrate.d.ts.map

package/dist/api/routes/setup-migrate.js

@@ -118,9 +118,12 @@ export function createSetupMigrateRoutes(deps) {
         }
         // Best-effort detection of whether templates were applied vs. only
         // placeholders — checked by looking for a representative template
-        // file (`rules/management.md` in plain mode indicates the templates
-        // tree was available).
-        const templatesUsed = existsSync(join(contextDir, "rules", "redaction.md"));
+        // file. `policies/redaction.md` (post-CONTEXT_VAULT_REDESIGN) is the
+        // canonical post-migration target; the legacy `rules/redaction.md` // drift-allow
+        // is still recognized so a vault that has not yet been migrated by
+        // the 0004 migration also flips this flag correctly.
+        const templatesUsed = existsSync(join(contextDir, "policies", "redaction.md")) ||
+            existsSync(join(contextDir, "rules", "redaction.md"));
         return c.json({
             status: "seeded",
             contextDir,
@@ -943,4 +946,3 @@ export function sweepExpiredMigrationBackups(db, opts = {}) {
     }
     return { swept, errors };
 }
-//# sourceMappingURL=setup-migrate.js.map

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

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

package/dist/api/routes/setup.js

@@ -15,7 +15,20 @@ import { createRecurringSchedule } from "../../db/recurring-schedules.js";
 import { createSettingsStore } from "../../settings/settings-store.js";
 import { cleanupSessionWorkdir, getSessionWorkdirPath } from "../../core/workdir.js";
 import { readJsonBody } from "../json-body.js";
+import { getVaultRestructureAck, getVaultRestructurePendingConsent, setVaultRestructureAck, } from "../../db/runtime-state.js";
 const logger = createLogger("api:setup");
+const EXECUTION_PERMISSION_SETTING_KEYS = {
+    claude: "claudeExecutionPermissionMode",
+    codex: "codexExecutionPermissionMode",
+    gemini: "geminiExecutionPermissionMode",
+    opencode: "opencodeExecutionPermissionMode",
+};
+function getExecutionPermissionMode(config, backend) {
+    return config[EXECUTION_PERMISSION_SETTING_KEYS[backend]];
+}
+function setExecutionPermissionMode(config, backend, mode) {
+    config[EXECUTION_PERMISSION_SETTING_KEYS[backend]] = mode;
+}
 /**
  * SCHEDULED-DM-IMPLEMENTATION-PLAN §6.6 — idempotently insert the
  * morning briefing recurring schedule on first save-rules. Returns
@@ -102,9 +115,9 @@ export function createSetupRoutes(deps) {
     // would write the skeleton + rules into the old location.
     // POST /setup/mode — Execution-mode setup step.
     //
-    // Body: { mode: "safe" | "allow", perBackend?: { claude?, codex?, gemini? } }
+    // Body: { mode: "safe" | "allow", perBackend?: { [backendId]?: "safe" | "allow" } }
     //
-    // Writes `{claude,codex,gemini}ExecutionPermissionMode` in one transaction.
+    // Writes each backend's `ExecutionPermissionMode` in one transaction.
     // Top-level `mode` is applied to every backend not covered by `perBackend`.
     // See EXECUTION-MODE-DESIGN.md §5.3 — the UI labels are `safe`/`allow`
     // but the settings rows use `strict`/`allow`, so this endpoint also owns
@@ -140,27 +153,25 @@ export function createSetupRoutes(deps) {
             }
         }
         const topInternal = modeUi === "safe" ? "strict" : "allow";
-        const resolved = {
-            claude: perBackend.claude ?? topInternal,
-            codex: perBackend.codex ?? topInternal,
-            gemini: perBackend.gemini ?? topInternal,
-        };
+        const resolved = Object.fromEntries(BACKEND_IDS.map((backend) => [
+            backend,
+            perBackend[backend] ?? topInternal,
+        ]));
         // Snapshot previous values so the audit row below can capture the
         // before → after transition per backend.
-        const before = {
-            claude: config.claudeExecutionPermissionMode,
-            codex: config.codexExecutionPermissionMode,
-            gemini: config.geminiExecutionPermissionMode,
-        };
+        const before = Object.fromEntries(BACKEND_IDS.map((backend) => [
+            backend,
+            getExecutionPermissionMode(config, backend),
+        ]));
         try {
-            settingsStore.setMany({
-                claudeExecutionPermissionMode: resolved.claude,
-                codexExecutionPermissionMode: resolved.codex,
-                geminiExecutionPermissionMode: resolved.gemini,
-            });
-            config.claudeExecutionPermissionMode = resolved.claude;
-            config.codexExecutionPermissionMode = resolved.codex;
-            config.geminiExecutionPermissionMode = resolved.gemini;
+            const updates = Object.fromEntries(BACKEND_IDS.map((backend) => [
+                EXECUTION_PERMISSION_SETTING_KEYS[backend],
+                resolved[backend],
+            ]));
+            settingsStore.setMany(updates);
+            for (const backend of BACKEND_IDS) {
+                setExecutionPermissionMode(config, backend, resolved[backend]);
+            }
         }
         catch (err) {
             return c.json({ error: toSafeErrorMessage(err, "failed_to_persist_execution_mode") }, 500);
@@ -171,7 +182,7 @@ export function createSetupRoutes(deps) {
         // distinct from the `blocked_absolute` row emitted by the
         // absolute-block classifier hook.
         const changed = [];
-        for (const backend of ["claude", "codex", "gemini"]) {
+        for (const backend of BACKEND_IDS) {
             if (before[backend] !== resolved[backend]) {
                 changed.push({
                     backend,
@@ -199,11 +210,10 @@ export function createSetupRoutes(deps) {
         return c.json({
             status: "applied",
             mode: modeUi,
-            resolved: {
-                claude: resolved.claude === "strict" ? "safe" : "allow",
-                codex: resolved.codex === "strict" ? "safe" : "allow",
-                gemini: resolved.gemini === "strict" ? "safe" : "allow",
-            },
+            resolved: Object.fromEntries(BACKEND_IDS.map((backend) => [
+                backend,
+                resolved[backend] === "strict" ? "safe" : "allow",
+            ])),
             changedRows: changed.length,
         });
     });
@@ -438,6 +448,111 @@ export function createSetupRoutes(deps) {
             status: isUpdate ? "updated" : "created",
         });
     });
+    // POST /setup/backends/opencode/probe — docs/design/appendices/opencode-backend.md
+    // §6.6.2 setup-wizard probe. Performs an autonomous-read health check
+    // against the managed loopback opencode server: enumerates providers
+    // and reports the live tool-use capability matrix so the wizard can
+    // surface "OpenCode is healthy with N providers, M models support
+    // tool-use" without committing a `backends` row.
+    //
+    // The probe is risk-classified as autonomous read by the
+    // `/api/setup` prefix rule in risk-classifier.ts (Approve tier — but
+    // the read side has no destructive blast radius; the wizard relays
+    // this to a UI that the operator confirms before mutating any
+    // `process_backend_config` row).
+    app.post("/setup/backends/opencode/probe", async (c) => {
+        const opencodeCore = deps.agentBackends?.find((core) => core.backendId === "opencode");
+        if (!opencodeCore) {
+            return c.json({
+                status: "error",
+                aitneSignal: "transient",
+                message: "OpenCode backend is not wired into this daemon build.",
+            }, 503);
+        }
+        try {
+            const auth = await opencodeCore.checkAuthDetailed();
+            if (!auth.ok) {
+                return c.json({
+                    status: "error",
+                    aitneSignal: auth.status === "expired" || auth.status === "missing"
+                        ? "auth-invalid"
+                        : "transient",
+                    message: auth.detail
+                        ?? "OpenCode server is not reachable or has no providers configured.",
+                    ...(auth.recoveryCommand
+                        ? { recoveryCommand: auth.recoveryCommand }
+                        : {}),
+                }, 200);
+            }
+            // Healthy — surface the model registry + tool-use breakdown
+            // (§6.1.2). Static-registry first; Phase 6 widens this with a
+            // live `client.config.providers()` capability sniff.
+            const models = opencodeCore.listModels();
+            const modelsTotal = models.length;
+            const modelsWithToolUse = models.filter((model) => model.supportsToolUse !== false).length;
+            const providers = Array.from(new Set(models.map((model) => {
+                const slash = model.modelId.indexOf("/");
+                return slash > 0 ? model.modelId.slice(0, slash) : model.modelId;
+            })));
+            return c.json({
+                status: "ok",
+                healthy: true,
+                mode: "managed",
+                providers,
+                modelsTotal,
+                modelsWithToolUse,
+                warnings: [],
+            });
+        }
+        catch (err) {
+            logger.warn({ err }, "opencode setup probe failed");
+            return c.json({
+                status: "error",
+                aitneSignal: "transient",
+                message: toSafeErrorMessage(err, "opencode_probe_failed"),
+            }, 200);
+        }
+    });
+    // CONTEXT_VAULT_REDESIGN_PLAN.md §11.3.4 / V16 — dashboard consent
+    // surface for the Obsidian-mode vault restructure. On Obsidian
+    // installs the boot layer defers the migration until the user opts
+    // in; this endpoint records that opt-in. The migration runs on the
+    // NEXT daemon boot — the response carries that instruction so the
+    // dashboard can ask the user to restart (or trigger a supervisor
+    // restart if one is wired).
+    //
+    // GET returns the current pending-consent state so the dashboard
+    // can decide whether to show the banner.
+    app.get("/setup/vault-restructure-status", (c) => {
+        const pending = getVaultRestructurePendingConsent(db);
+        const ack = getVaultRestructureAck(db);
+        return c.json({
+            pendingConsent: pending,
+            acknowledgement: ack,
+        });
+    });
+    app.post("/setup/vault-restructure-ack", async (c) => {
+        const ack = getVaultRestructureAck(db);
+        if (ack) {
+            return c.json({
+                ok: true,
+                alreadyAcknowledged: true,
+                acknowledgement: ack,
+                restartRequired: false,
+                message: "Vault restructure consent was already recorded; nothing to do.",
+            }, 200);
+        }
+        setVaultRestructureAck(db, {
+            at: new Date().toISOString(),
+            source: "dashboard",
+        });
+        logger.info({ source: "dashboard" }, "Vault restructure consent recorded — migration will run on next daemon boot.");
+        return c.json({
+            ok: true,
+            alreadyAcknowledged: false,
+            restartRequired: true,
+            message: "Consent recorded. Restart the daemon (e.g. `aitne restart`) to run the vault restructure.",
+        }, 200);
+    });
     return app;
 }
-//# sourceMappingURL=setup.js.map

package/dist/api/routes/skill-curation.d.ts

@@ -2,4 +2,3 @@ import { Hono } from "hono";
 import type { ApiDependencies } from "../server.js";
 export declare function createSkillCurationRoutes(deps: ApiDependencies): Hono;
 export declare const SKILL_CURATION_KINDS: readonly ["knowledge_layout", "routing_table", "frontmatter_schema", "search_recipes", "convention_notes", "cross_references"];
-//# sourceMappingURL=skill-curation.d.ts.map

package/dist/api/routes/skill-curation.js

@@ -725,4 +725,3 @@ function safeParse(s) {
 // Reserved for future use — when the daemon needs to enumerate every kind
 // (e.g. for the `knowledge-map` query routing).
 export const SKILL_CURATION_KINDS = SECTION_KINDS;
-//# sourceMappingURL=skill-curation.js.map

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

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { type SkillSummary } from "@aitne/shared";
 import type { AgentConfig } from "../../config.js";
+import { resolveUserSkillsRoot } from "../../core/user-skills-root.js";
 /**
  * Skills API — CRUD over *user-authored* Claude Code skills.
  *
@@ -55,6 +56,6 @@ declare function safeSkillPath(root: string, slug: string): string | null;
  * to a flat scan when no category subdirs are present.
  */
 declare function listSkillsInRoot(root: string, builtin: boolean): SkillSummary[];
+export { resolveUserSkillsRoot };
 export declare function createSkillsRoutes(deps: SkillsRouteDependencies): Hono;
 export { parseSkillFile, serializeSkillFile, safeSkillPath, listSkillsInRoot };
-//# sourceMappingURL=skills.d.ts.map