hivehq 2.0.0

package/dist/src/server/routes-marketplace.js

@@ -0,0 +1,54 @@
+import { isMarketplaceLanguage, loadManifest, MarketplaceNotFoundError, readAgent, } from './marketplace-store.js';
+import { route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+const readLanguageParam = (request) => {
+    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    return url.searchParams.get('lang');
+};
+const readPathParam = (request) => {
+    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    return url.searchParams.get('path') ?? '';
+};
+export const marketplaceRoutes = [
+    route('GET', '/api/marketplace/manifest', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const lang = readLanguageParam(request);
+        if (!isMarketplaceLanguage(lang)) {
+            sendJson(response, 400, { error: 'Invalid or missing lang parameter (expected en|zh)' });
+            return;
+        }
+        try {
+            sendJson(response, 200, loadManifest(lang));
+        }
+        catch (error) {
+            if (error instanceof MarketplaceNotFoundError) {
+                sendJson(response, 404, { error: error.message });
+                return;
+            }
+            throw error;
+        }
+    }),
+    route('GET', '/api/marketplace/agent', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const lang = readLanguageParam(request);
+        if (!isMarketplaceLanguage(lang)) {
+            sendJson(response, 400, { error: 'Invalid or missing lang parameter (expected en|zh)' });
+            return;
+        }
+        const relativePath = readPathParam(request);
+        if (!relativePath) {
+            sendJson(response, 400, { error: 'Missing path parameter' });
+            return;
+        }
+        try {
+            sendJson(response, 200, readAgent(lang, relativePath));
+        }
+        catch (error) {
+            if (error instanceof MarketplaceNotFoundError) {
+                sendJson(response, 404, { error: error.message });
+                return;
+            }
+            throw error;
+        }
+    }),
+];

package/dist/src/server/routes-open-workspace.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const openWorkspaceRoutes: RouteDefinition[];

package/dist/src/server/routes-open-workspace.js

@@ -0,0 +1,47 @@
+import { isOpenTargetId } from './open-target-commands.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+export const openWorkspaceRoutes = [
+    route('POST', '/api/workspaces/:workspaceId/open', async ({ openWorkspaceService, params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId)
+            return;
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        if (!isOpenTargetId(body.target_id)) {
+            sendJson(response, 400, { error: 'Unknown open target', target_id: body.target_id });
+            return;
+        }
+        // store.getWorkspaceSnapshot throws raw Error("Workspace not found: ...")
+        // for missing workspaces — translate that to 404 here rather than letting
+        // app.ts catch it as a generic 500.
+        let workspacePath;
+        try {
+            workspacePath = store.getWorkspaceSnapshot(workspaceId).summary.path;
+        }
+        catch {
+            sendJson(response, 404, { error: 'Workspace not found' });
+            return;
+        }
+        const result = await openWorkspaceService({
+            path: workspacePath,
+            targetId: body.target_id,
+        });
+        if (result.ok) {
+            sendJson(response, 200, {
+                ok: true,
+                effective_target_id: result.effectiveTargetId,
+            });
+            return;
+        }
+        // Drop stderr from the wire response — defense in depth. The frontend
+        // never renders raw stderr (toast text is localized via error_code), so
+        // there's no reason to ship the OS-level message to the browser where
+        // it would live in the devtools network log.
+        sendJson(response, 502, {
+            ok: false,
+            effective_target_id: result.effectiveTargetId,
+            error_code: result.errorCode,
+        });
+    }),
+];

package/dist/src/server/routes-remote.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const remoteRoutes: RouteDefinition[];

package/dist/src/server/routes-remote.js

@@ -0,0 +1,166 @@
+import { ForbiddenError } from './http-errors.js';
+import { REMOTE_DAEMON_TOKEN_KEY, REMOTE_ENABLED_KEY, REMOTE_GATEWAY_URL_KEY, } from './remote-config-keys.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+// Remote-access device-management + pairing routes (M4). Two gate classes:
+//   - gateUi: the standard local-OR-tunnel gate every equal-authority route uses. A paired phone may
+//     reach these (list devices, revoke, status, audit) exactly like the desktop.
+//   - gateLocalDesktopOnly: the TRUST ROOT (Authority Model). Pairing begin/confirm/reject can ONLY be
+//     driven from the local desktop cookie path; a tunnel-tagged (phone) request is refused with 403.
+//     This is a pairing-ceremony invariant, NOT a feature permission — a phone can never self-approve
+//     a new device. Defense in depth: these three paths are ALSO hard-denied on the bridge
+//     (remote-bridge-routing DENIED pairing matcher), so even a bypassed gate gets Reset there.
+// Standard local-OR-tunnel gate. A request with no secret header falls to the cookie path (a browser);
+// a tunnel-stamped request short-circuits as authorized. Used by the equal-authority endpoints.
+const gateUi = ({ request, store }) => {
+    requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+};
+// TRUST-ROOT gate: local desktop ONLY. A tunnel-tagged request (authorizeRemoteTunnelRequest === true)
+// is a phone; refuse it. We audit the forbidden attempt with the concrete reason BEFORE throwing
+// (HARDEN D0.3): the audit spec lists "被拒请求及原因" as a required audited action, and the route is
+// the only layer that can attribute a 403 here to 'pairing_confirm_forbidden' (the bridge's onEnd
+// audits the loopback request status-agnostically). Then we pass NO tunnel authorizer to the token
+// check, so even the short-circuit can't admit a tunnel request that slipped a cookie too.
+const gateLocalDesktopOnly = ({ request, store }) => {
+    if (store.authorizeRemoteTunnelRequest(request)) {
+        store.getRemoteAuditStore().enqueue({
+            action: 'reject',
+            result: 'rejected',
+            rejectReason: 'pairing_confirm_forbidden',
+        });
+        throw new ForbiddenError('device approval is desktop-only');
+    }
+    requireUiTokenFromRequest(request, store.validateUiToken);
+};
+const isLoggedIn = (store) => (store.settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null) !== null &&
+    (store.settings.getAppState(REMOTE_DAEMON_TOKEN_KEY)?.value ?? null) !== null;
+const remoteStatus = (store) => {
+    const status = store.getRemoteTunnelStatus();
+    return {
+        enabled: store.settings.getAppState(REMOTE_ENABLED_KEY)?.value === 'true',
+        loggedIn: isLoggedIn(store),
+        gatewayUrl: store.settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null,
+        connected: status === 'online',
+        // The FULL tunnel state, not just online/offline — the desktop dot was stuck looking "connected or
+        // not" and couldn't show connecting / reconnecting / revoked / logged-out. (connecting+reconnecting
+        // are the states a flaky link spends real time in; surfacing them is what makes the dot honest.)
+        connection: status,
+    };
+};
+// RemoteDeviceRecord is already camelCase + metadata-only (no key material). Identity-mapped so the
+// response shape stays pinned to the store's invariant-7 projection.
+const toDeviceView = (record) => ({
+    id: record.id,
+    name: record.name,
+    createdAt: record.createdAt,
+    lastActive: record.lastActive,
+    revokedAt: record.revokedAt,
+});
+export const remoteRoutes = [
+    route('GET', '/api/remote/status', (ctx) => {
+        gateUi(ctx);
+        sendJson(ctx.response, 200, remoteStatus(ctx.store));
+    }),
+    route('PUT', '/api/remote/enabled', async (ctx) => {
+        const { request, response, store } = ctx;
+        const body = await readJsonBody(request);
+        const enabled = body.enabled === true;
+        // D0.4 — conditional gate: a remote MAY turn the tunnel OFF (self-disconnect) but NEVER ON. So a
+        // tunnel-tagged enable:true is the only enabled-route action that is desktop-only.
+        if (enabled && store.authorizeRemoteTunnelRequest(request)) {
+            throw new ForbiddenError('remote cannot self-enable');
+        }
+        gateUi(ctx);
+        store.setRemoteEnabled(enabled);
+        sendJson(response, 200, remoteStatus(store));
+    }),
+    // ── trust-root pairing set (desktop-only) ──────────────────────────────────────────────────────
+    route('POST', '/api/remote/pairings', (ctx) => {
+        gateLocalDesktopOnly(ctx);
+        if (!isLoggedIn(ctx.store)) {
+            sendJson(ctx.response, 503, { error: 'remote not logged in' });
+            return;
+        }
+        try {
+            const ticket = ctx.store.getRemotePairing().beginPairing();
+            sendJson(ctx.response, 200, ticket);
+        }
+        catch {
+            // beginPairing throws if gateway/daemon id vanished between the status read and here.
+            sendJson(ctx.response, 503, { error: 'remote not logged in' });
+        }
+    }),
+    route('GET', '/api/remote/pairings/pending', (ctx) => {
+        // HARDEN minor: desktop-only. The confirm dialog backs this; a phone has no use for another
+        // device's in-flight SAS, and exposing it would needlessly widen the secret surface (invariant 7).
+        gateLocalDesktopOnly(ctx);
+        sendJson(ctx.response, 200, ctx.store.getRemotePairing().listPending());
+    }),
+    route('POST', '/api/remote/pairings/:pairingId/confirm', async (ctx) => {
+        const { params, request, response, store } = ctx;
+        const pairingId = getRequiredParam(response, params, 'pairingId', 'Pairing id is required');
+        if (!pairingId)
+            return;
+        gateLocalDesktopOnly(ctx);
+        const body = await readJsonBody(request).catch(() => ({}));
+        // THE trust-root action (D3): confirmRemotePairing drives the engine's local insert (the only
+        // caller of deviceStore.insert) AND the gateway device-row registration + the `confirmed` signal
+        // to the phone, in that order. A gateway-POST failure (or a missing boundJti) rejects here: the
+        // local row exists but the phone is NOT told OK, so it can re-scan. Surface 502 so the desktop
+        // operator sees the pairing didn't complete end-to-end rather than a false success.
+        let record;
+        try {
+            record = await store.confirmRemotePairing(pairingId, body.name === undefined ? undefined : body.name);
+        }
+        catch {
+            sendJson(response, 502, { error: 'gateway registration failed; rescan to retry' });
+            return;
+        }
+        if (!record) {
+            // Unknown / expired / wrong-state pairing. Nothing persisted.
+            sendJson(response, 404, { error: 'pairing not found or no longer confirmable' });
+            return;
+        }
+        // The newly-persisted device is live in the provider now. Reconcile the tunnel so a freshly
+        // enabled remote starts connecting (no-op if already online / disabled).
+        store.setRemoteEnabled(store.settings.getAppState(REMOTE_ENABLED_KEY)?.value === 'true');
+        sendJson(response, 200, { device: toDeviceView(record) });
+    }),
+    route('POST', '/api/remote/pairings/:pairingId/reject', (ctx) => {
+        const { params, response, store } = ctx;
+        const pairingId = getRequiredParam(response, params, 'pairingId', 'Pairing id is required');
+        if (!pairingId)
+            return;
+        gateLocalDesktopOnly(ctx);
+        store.getRemotePairing().rejectPairing(pairingId, 'user_rejected');
+        response.statusCode = 204;
+        response.end();
+    }),
+    // ── equal-authority device management ──────────────────────────────────────────────────────────
+    route('GET', '/api/remote/devices', (ctx) => {
+        gateUi(ctx);
+        const includeRevoked = new URL(ctx.request.url ?? '', 'http://x').searchParams.has('includeRevoked');
+        sendJson(ctx.response, 200, ctx.store.getRemoteDeviceStore().list(includeRevoked).map(toDeviceView));
+    }),
+    route('POST', '/api/remote/devices/:deviceId/revoke', (ctx) => {
+        const { params, response, store } = ctx;
+        const deviceId = getRequiredParam(response, params, 'deviceId', 'Device id is required');
+        if (!deviceId)
+            return;
+        gateUi(ctx);
+        // Revocation closed loop (§6 orchestrator in the runtime store): provider drop + tunnel close +
+        // audit. Equal-authority: a phone may revoke any device, including itself.
+        store.revokeRemoteDevice(deviceId);
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('GET', '/api/remote/audit', (ctx) => {
+        gateUi(ctx);
+        const url = new URL(ctx.request.url ?? '', 'http://x');
+        const rawLimit = Number(url.searchParams.get('limit'));
+        const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, 500) : 100;
+        const deviceId = url.searchParams.get('deviceId');
+        const audit = ctx.store.getRemoteAuditStore();
+        sendJson(ctx.response, 200, deviceId ? audit.listForDevice(deviceId, limit) : audit.list(limit));
+    }),
+];

package/dist/src/server/routes-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const runtimeRoutes: RouteDefinition[];

package/dist/src/server/routes-runtime.js

@@ -0,0 +1,79 @@
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { serializeLiveAgentRun } from './workflow-http-serializers.js';
+import { getWorkspaceShellAgentId } from './workspace-shell-runtime.js';
+export const runtimeRoutes = [
+    route('GET', '/api/ui/workspaces/:workspaceId/runs', ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        sendJson(response, 200, store.listTerminalRuns(workspaceId));
+    }),
+    route('POST', '/api/workspaces/:workspaceId/shell/start', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const run = await store.startWorkspaceShell(workspaceId);
+        const summary = store
+            .listTerminalRuns(workspaceId)
+            .find((terminalRun) => terminalRun.run_id === run.runId);
+        sendJson(response, 201, {
+            agent_id: getWorkspaceShellAgentId(workspaceId),
+            agent_name: summary?.agent_name ?? 'Shell',
+            run_id: run.runId,
+            status: run.status,
+            terminal_input_profile: summary?.terminal_input_profile ?? 'default',
+        });
+    }),
+    route('DELETE', '/api/workspaces/:workspaceId/shell/:runId', ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and run id are required');
+        const runId = getRequiredParam(response, params, 'runId', 'Workspace id and run id are required');
+        if (!workspaceId || !runId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        if (!store.closeWorkspaceShell(workspaceId, runId)) {
+            sendJson(response, 404, { error: 'Shell run not found' });
+            return;
+        }
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('POST', '/api/workspaces/:workspaceId/agents/:agentId/config', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and agent id are required');
+        const agentId = getRequiredParam(response, params, 'agentId', 'Workspace id and agent id are required');
+        if (!workspaceId || !agentId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        store.configureAgentLaunch(workspaceId, agentId, {
+            command: body.command,
+            commandPresetId: body.command_preset_id ?? null,
+            ...(body.args ? { args: body.args } : {}),
+        });
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('POST', '/api/runtime/runs/:runId/stop', ({ params, request, response, store }) => {
+        const runId = getRequiredParam(response, params, 'runId', 'Run id is required');
+        if (!runId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        store.stopAgentRun(runId);
+        sendJson(response, 202, { ok: true });
+    }),
+    route('GET', '/api/runtime/runs/:runId', ({ params, request, response, store }) => {
+        const runId = getRequiredParam(response, params, 'runId', 'Run id is required');
+        if (!runId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        sendJson(response, 200, serializeLiveAgentRun(store.getLiveRun(runId)));
+    }),
+];

package/dist/src/server/routes-settings.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const settingsRoutes: RouteDefinition[];

package/dist/src/server/routes-settings.js

@@ -0,0 +1,213 @@
+import { resolveCommandPath } from './agent-command-resolver.js';
+import { readFeatureFlags } from './feature-flags.js';
+import { BadRequestError } from './http-errors.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { ensureProtocolFile } from './tasks-file.js';
+import { AUTOSTAFF_ENABLED_KEY, readAutostaffEnabled, serializeAutostaffEnabled, } from './team-autostaff.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { assertValidWorkflowCliPolicy, CANONICAL_WORKFLOW_CLIS, readWorkflowCliPolicy, WORKFLOW_CLI_POLICY_KEY, } from './workflow-cli-policy.js';
+import { readWorkflowEnabled, serializeWorkflowEnabled, WORKFLOW_ENABLED_KEY, } from './workflow-feature.js';
+const serializeCommandPreset = (preset) => {
+    let available = false;
+    try {
+        if (preset.command.trim()) {
+            resolveCommandPath(preset.command, process.cwd(), { ...process.env, ...preset.env });
+            available = true;
+        }
+    }
+    catch {
+        available = false;
+    }
+    return {
+        id: preset.id,
+        display_name: preset.displayName,
+        command: preset.command,
+        args: preset.args,
+        env: preset.env,
+        resume_args_template: preset.resumeArgsTemplate,
+        session_id_capture: preset.sessionIdCapture,
+        yolo_args_template: preset.yoloArgsTemplate,
+        is_builtin: preset.isBuiltin,
+        available,
+    };
+};
+const serializeRoleTemplate = (template) => ({
+    id: template.id,
+    name: template.name,
+    role_type: template.roleType,
+    description: template.description,
+    default_command: template.defaultCommand,
+    default_args: template.defaultArgs,
+    default_env: template.defaultEnv,
+    is_builtin: template.isBuiltin,
+});
+/**
+ * Rewrite every open workspace's `.hive/PROTOCOL.md` to match the just-saved
+ * workflow feature flag + CLI policy. Without this the doc only refreshes on
+ * the next workspace open / watcher start, so toggling the feature would leave
+ * stale guidance (workflow DSL still present after disabling, or absent right
+ * after enabling). Idempotent: ensureProtocolFile only rewrites on change.
+ */
+const refreshWorkflowProtocolDocs = (store) => {
+    const policy = readWorkflowCliPolicy(store.settings.getAppState(WORKFLOW_CLI_POLICY_KEY)?.value ?? null);
+    const flags = readFeatureFlags(store.settings);
+    for (const workspace of store.listWorkspaces()) {
+        try {
+            ensureProtocolFile(workspace.path, policy, flags);
+        }
+        catch (error) {
+            console.error('[hive] swallowed:settings.refreshProtocol', error);
+        }
+    }
+};
+const readCommandPresetBody = async (request) => {
+    const body = await readJsonBody(request);
+    return {
+        displayName: body.display_name ?? '',
+        command: body.command ?? '',
+        args: body.args ?? [],
+        env: body.env ?? {},
+        resumeArgsTemplate: body.resume_args_template ?? null,
+        sessionIdCapture: body.session_id_capture ?? null,
+        yoloArgsTemplate: body.yolo_args_template ?? null,
+    };
+};
+const readRoleTemplateBody = async (request) => {
+    const body = await readJsonBody(request);
+    return {
+        name: body.name ?? '',
+        roleType: body.role_type ?? 'custom',
+        description: body.description ?? '',
+        defaultCommand: body.default_command ?? '',
+        defaultArgs: body.default_args ?? [],
+        defaultEnv: body.default_env ?? {},
+    };
+};
+export const settingsRoutes = [
+    route('GET', '/api/settings/command-presets', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        sendJson(response, 200, store.settings.listCommandPresets().map(serializeCommandPreset));
+    }),
+    route('POST', '/api/settings/command-presets', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        sendJson(response, 201, serializeCommandPreset(store.settings.createCommandPreset(await readCommandPresetBody(request))));
+    }),
+    route('PATCH', '/api/settings/command-presets/:presetId', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const presetId = getRequiredParam(response, params, 'presetId', 'Preset id is required');
+        if (!presetId)
+            return;
+        const current = store.settings.listCommandPresets().find((preset) => preset.id === presetId);
+        if (!current)
+            throw new Error(`Command preset not found: ${presetId}`);
+        const next = { ...current, ...(await readCommandPresetBody(request)) };
+        sendJson(response, 200, serializeCommandPreset(store.settings.updateCommandPreset(presetId, next)));
+    }),
+    route('DELETE', '/api/settings/command-presets/:presetId', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const presetId = getRequiredParam(response, params, 'presetId', 'Preset id is required');
+        if (!presetId)
+            return;
+        store.settings.deleteCommandPreset(presetId);
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('GET', '/api/settings/role-templates', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        sendJson(response, 200, store.settings.listRoleTemplates().map(serializeRoleTemplate));
+    }),
+    route('POST', '/api/settings/role-templates', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        sendJson(response, 201, serializeRoleTemplate(store.settings.createRoleTemplate(await readRoleTemplateBody(request))));
+    }),
+    route('PATCH', '/api/settings/role-templates/:templateId', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const templateId = getRequiredParam(response, params, 'templateId', 'Template id is required');
+        if (!templateId)
+            return;
+        const current = store.settings
+            .listRoleTemplates()
+            .find((template) => template.id === templateId);
+        if (!current)
+            throw new Error(`Role template not found: ${templateId}`);
+        const next = { ...current, ...(await readRoleTemplateBody(request)) };
+        sendJson(response, 200, serializeRoleTemplate(store.settings.updateRoleTemplate(templateId, next)));
+    }),
+    route('DELETE', '/api/settings/role-templates/:templateId', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const templateId = getRequiredParam(response, params, 'templateId', 'Template id is required');
+        if (!templateId)
+            return;
+        store.settings.deleteRoleTemplate(templateId);
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('GET', '/api/settings/app-state/:key', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const key = getRequiredParam(response, params, 'key', 'App state key is required');
+        if (!key)
+            return;
+        sendJson(response, 200, store.settings.getAppState(key) ?? { key, value: null });
+    }),
+    route('PUT', '/api/settings/app-state/:key', async ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const key = getRequiredParam(response, params, 'key', 'App state key is required');
+        if (!key)
+            return;
+        const body = await readJsonBody(request);
+        store.settings.setAppState(key, body.value);
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('GET', '/api/settings/workflow-cli-policy', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const policy = readWorkflowCliPolicy(store.settings.getAppState(WORKFLOW_CLI_POLICY_KEY)?.value ?? null);
+        sendJson(response, 200, { ...policy, supported: [...CANONICAL_WORKFLOW_CLIS] });
+    }),
+    route('PUT', '/api/settings/workflow-cli-policy', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        // Strict validation: a bad payload is rejected (400) rather than persisted.
+        const clean = (() => {
+            try {
+                return assertValidWorkflowCliPolicy(body);
+            }
+            catch (error) {
+                throw new BadRequestError(error instanceof Error ? error.message : String(error));
+            }
+        })();
+        store.settings.setAppState(WORKFLOW_CLI_POLICY_KEY, JSON.stringify(clean));
+        refreshWorkflowProtocolDocs(store);
+        sendJson(response, 200, { ...clean, supported: [...CANONICAL_WORKFLOW_CLIS] });
+    }),
+    route('GET', '/api/settings/workflow-feature', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const enabled = readWorkflowEnabled(store.settings.getAppState(WORKFLOW_ENABLED_KEY)?.value ?? null);
+        sendJson(response, 200, { enabled });
+    }),
+    route('PUT', '/api/settings/workflow-feature', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        if (typeof body.enabled !== 'boolean') {
+            throw new BadRequestError('workflow-feature requires { enabled: boolean }');
+        }
+        store.settings.setAppState(WORKFLOW_ENABLED_KEY, serializeWorkflowEnabled(body.enabled));
+        refreshWorkflowProtocolDocs(store);
+        sendJson(response, 200, { enabled: body.enabled });
+    }),
+    route('GET', '/api/settings/team-autostaff', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const enabled = readAutostaffEnabled(store.settings.getAppState(AUTOSTAFF_ENABLED_KEY)?.value ?? null);
+        sendJson(response, 200, { enabled });
+    }),
+    route('PUT', '/api/settings/team-autostaff', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        if (typeof body.enabled !== 'boolean') {
+            throw new BadRequestError('team-autostaff requires { enabled: boolean }');
+        }
+        store.settings.setAppState(AUTOSTAFF_ENABLED_KEY, serializeAutostaffEnabled(body.enabled));
+        refreshWorkflowProtocolDocs(store);
+        sendJson(response, 200, { enabled: body.enabled });
+    }),
+];

package/dist/src/server/routes-tasks.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const taskRoutes: RouteDefinition[];

package/dist/src/server/routes-tasks.js

@@ -0,0 +1,47 @@
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { computeRunnableTasks } from './task-deps.js';
+import { authenticateCliAgent, requireCommandForRole } from './team-authz.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+export const taskRoutes = [
+    route('GET', '/api/workspaces/:workspaceId/tasks/next', ({ params, request, response, store, tasksFileService }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        // CLI-agent auth (mirrors `team list`): `team next` is an orchestrator
+        // planning query, not a UI call.
+        const agentId = request.headers['x-hive-agent-id'];
+        const token = request.headers['x-hive-agent-token'];
+        const agent = authenticateCliAgent({
+            fromAgentId: typeof agentId === 'string' ? agentId : undefined,
+            getAgent: store.getAgent,
+            token: typeof token === 'string' ? token : undefined,
+            validateToken: store.validateAgentToken,
+            workspaceId,
+        });
+        requireCommandForRole(agent, 'next');
+        const workspace = store.getWorkspaceSnapshot(workspaceId);
+        const tasks = computeRunnableTasks(tasksFileService.readTasks(workspace.summary.path));
+        sendJson(response, 200, { tasks });
+    }),
+    route('GET', '/api/workspaces/:workspaceId/tasks', ({ params, request, response, store, tasksFileService }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspace = store.getWorkspaceSnapshot(workspaceId);
+        sendJson(response, 200, { content: tasksFileService.readTasks(workspace.summary.path) });
+    }),
+    route('PUT', '/api/workspaces/:workspaceId/tasks', async ({ params, request, response, store, tasksFileService }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        const workspace = store.getWorkspaceSnapshot(workspaceId);
+        tasksFileService.writeTasks(workspace.summary.path, body.content);
+        sendJson(response, 200, { content: body.content });
+    }),
+];

package/dist/src/server/routes-team-memory.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const teamMemoryRoutes: RouteDefinition[];