create-principles-disciple 1.94.0 → 1.96.0

package/console/dist/server/routes/intent.js

@@ -0,0 +1,223 @@
+import { IntentPageModel } from '../models/IntentPageModel.js';
+import { sendSuccess, sendError, sendJson } from '../utils/response.js';
+import { loadPdConfig, computeFlagsFromLoadResult } from '../config/pd-config-store.js';
+import { readBody } from '../utils/request.js';
+/** Parse lang from query string; default 'zh-CN' if missing/invalid. */
+function parseLang(req) {
+    const url = new URL(req.url ?? '', 'http://localhost');
+    const lang = url.searchParams.get('lang');
+    return lang === 'en' ? 'en' : 'zh-CN';
+}
+const MODEL_CACHE_TTL_MS = 30 * 1000;
+const models = new Map();
+function getModel(workspaceDir) {
+    const cached = models.get(workspaceDir);
+    if (cached && Date.now() - cached.cachedAt < MODEL_CACHE_TTL_MS) {
+        return cached.model;
+    }
+    const model = new IntentPageModel(workspaceDir);
+    models.set(workspaceDir, { model, cachedAt: Date.now() });
+    return model;
+}
+/** Load the intent_engineering flag state from config. */
+function loadFlagEnabled(workspaceDir) {
+    const configResult = loadPdConfig(workspaceDir);
+    const flagsResult = computeFlagsFromLoadResult(configResult);
+    return flagsResult.flags.intent_engineering?.enabled === true;
+}
+/** Send a structured error with reason + nextAction (Runtime Contract Rule #9). */
+function sendStructuredError(res, payload) {
+    sendError(res, payload.statusCode, payload.error, payload.reason, {
+        reason: payload.reason,
+        nextAction: payload.nextAction,
+    });
+}
+export async function handleIntentRoute(req, res, ctx) {
+    const { workspaceDir, subPath } = ctx;
+    const lang = parseLang(req);
+    try {
+        // ── GET /api/v1/intent — read Intent summary ──────────────────────────
+        if (req.method === 'GET' && subPath === '') {
+            const flagEnabled = loadFlagEnabled(workspaceDir);
+            const model = getModel(workspaceDir);
+            const summary = await model.getSummary(flagEnabled, lang);
+            sendSuccess(res, summary);
+            return;
+        }
+        // ── GET /api/v1/intent/content — read raw INTENT.md for editing ─────────
+        if (req.method === 'GET' && subPath === '/content') {
+            const flagEnabled = loadFlagEnabled(workspaceDir);
+            if (!flagEnabled) {
+                sendStructuredError(res, {
+                    statusCode: 403,
+                    error: 'flag_disabled',
+                    reason: 'flag_disabled',
+                    nextAction: 'Enable the intent_engineering feature flag first.',
+                });
+                return;
+            }
+            const model = getModel(workspaceDir);
+            const result = await model.getRawContent(flagEnabled, lang);
+            if (!result.ok) {
+                // Map model error reason → HTTP status (rc-9-no-silent-fallback).
+                // not_found → 404; oversized → 413 (Payload Too Large, matches the
+                // byte-budget contract with getSummary); read_error / unknown → 500.
+                const statusCode = result.reason === 'not_found' ? 404 :
+                    result.reason === 'oversized' ? 413 :
+                        result.reason === 'flag_disabled' ? 403 :
+                            500;
+                sendStructuredError(res, {
+                    statusCode,
+                    error: result.reason ?? 'intent_content_error',
+                    reason: result.reason ?? 'unknown',
+                    nextAction: result.nextAction,
+                });
+                return;
+            }
+            sendSuccess(res, { content: result.content, path: result.path });
+            return;
+        }
+        // ── GET /api/v1/intent/versions — list version history ────────────────
+        if (req.method === 'GET' && subPath === '/versions') {
+            const model = getModel(workspaceDir);
+            const result = await model.getVersions(lang);
+            if (!result.ok) {
+                sendSuccess(res, { versions: [], reason: result.reason, nextAction: result.nextAction });
+                return;
+            }
+            sendSuccess(res, { versions: result.versions });
+            return;
+        }
+        // ── POST /api/v1/intent/init — create INTENT.md template ──────────────
+        if (req.method === 'POST' && subPath === '/init') {
+            const flagEnabled = loadFlagEnabled(workspaceDir);
+            if (!flagEnabled) {
+                sendStructuredError(res, {
+                    statusCode: 403,
+                    error: 'flag_disabled',
+                    reason: 'flag_disabled',
+                    nextAction: 'Enable the intent_engineering feature flag first.',
+                });
+                return;
+            }
+            const body = await readBody(req);
+            let parsedBody = {};
+            if (body.trim().length > 0) {
+                try {
+                    parsedBody = JSON.parse(body);
+                }
+                catch {
+                    sendStructuredError(res, {
+                        statusCode: 400,
+                        error: 'bad_request',
+                        reason: 'invalid_json',
+                        nextAction: 'Request body must be valid JSON.',
+                    });
+                    return;
+                }
+            }
+            // Extract force flag (default false — don't overwrite existing file)
+            let force = false;
+            if (parsedBody !== null && typeof parsedBody === 'object' && Object.hasOwn(parsedBody, 'force')) {
+                const forceVal = parsedBody.force;
+                if (typeof forceVal === 'boolean') {
+                    force = forceVal;
+                }
+            }
+            const model = getModel(workspaceDir);
+            const result = await model.createTemplate(flagEnabled, force, lang);
+            if (result.ok) {
+                if (result.created) {
+                    sendJson(res, 201, { success: true, data: result });
+                }
+                else {
+                    // already_exists — return 200 with reason
+                    sendSuccess(res, result);
+                }
+            }
+            else {
+                sendStructuredError(res, {
+                    statusCode: 500,
+                    error: 'intent_init_error',
+                    reason: result.reason ?? 'unknown',
+                    nextAction: result.nextAction,
+                });
+            }
+            return;
+        }
+        // ── PUT /api/v1/intent/content — save INTENT.md content ───────────────
+        if (req.method === 'PUT' && subPath === '/content') {
+            const flagEnabled = loadFlagEnabled(workspaceDir);
+            if (!flagEnabled) {
+                sendStructuredError(res, {
+                    statusCode: 403,
+                    error: 'flag_disabled',
+                    reason: 'flag_disabled',
+                    nextAction: 'Enable the intent_engineering feature flag first.',
+                });
+                return;
+            }
+            const body = await readBody(req);
+            let parsedBody;
+            try {
+                parsedBody = JSON.parse(body);
+            }
+            catch {
+                sendStructuredError(res, {
+                    statusCode: 400,
+                    error: 'bad_request',
+                    reason: 'invalid_json',
+                    nextAction: 'Request body must be valid JSON.',
+                });
+                return;
+            }
+            // Runtime Contract Rule #1: treat as unknown, validate with Object.hasOwn
+            if (parsedBody === null || typeof parsedBody !== 'object' || Array.isArray(parsedBody)) {
+                sendStructuredError(res, {
+                    statusCode: 400,
+                    error: 'bad_request',
+                    reason: 'invalid_body',
+                    nextAction: 'Request body must be a JSON object with a "content" field.',
+                });
+                return;
+            }
+            const bodyObj = parsedBody;
+            if (!Object.hasOwn(bodyObj, 'content')) {
+                sendStructuredError(res, {
+                    statusCode: 400,
+                    error: 'bad_request',
+                    reason: 'missing_content',
+                    nextAction: 'Request body must include a "content" string field.',
+                });
+                return;
+            }
+            const model = getModel(workspaceDir);
+            const result = await model.saveContent(flagEnabled, bodyObj.content, lang);
+            if (result.ok) {
+                sendSuccess(res, result);
+            }
+            else {
+                // Map known reasons to HTTP status codes
+                const statusCode = result.reason === 'invalid_content' || result.reason === 'empty_content' || result.reason === 'oversized'
+                    ? 400
+                    : 500;
+                sendStructuredError(res, {
+                    statusCode,
+                    error: 'intent_save_error',
+                    reason: result.reason ?? 'unknown',
+                    nextAction: result.nextAction,
+                });
+            }
+            return;
+        }
+        // ── Unknown sub-path ──────────────────────────────────────────────────
+        sendError(res, 404, 'not_found', `Route /api/v1/intent${subPath} not found`);
+    }
+    catch (err) {
+        sendError(res, 500, 'intent_route_error', err instanceof Error ? err.message : 'Unknown error');
+    }
+}
+export function disposeIntentModels() {
+    // IntentPageModel holds no persistent resources; just clear the cache.
+    models.clear();
+}

package/console/dist/server/routes/principles.js

@@ -73,11 +73,77 @@ async function getDecidedPrincipleIds(workspaceDir) {
     }
 }
 export async function handlePrinciplesRoute({ req, res, workspaceDir, subPath, }) {
+    const model = getModel(workspaceDir);
+    // ── POST Routes ─────────────────────────────────────────────────────────────
+    if (req.method === 'POST') {
+        // POST /api/principles/:id/archive
+        const archiveMatch = /^\/([^/]*)\/archive$/.exec(subPath);
+        if (archiveMatch) {
+            const [, rawPrincipleId] = archiveMatch;
+            if (!rawPrincipleId) {
+                sendError(res, 400, 'invalid_principle_id', 'Principle ID is missing');
+                return;
+            }
+            let principleId;
+            try {
+                principleId = decodeURIComponent(rawPrincipleId);
+            }
+            catch {
+                sendError(res, 400, 'invalid_principle_id', 'Principle ID contains invalid URL encoding');
+                return;
+            }
+            try {
+                const ok = await model.archivePrinciple(principleId);
+                if (ok) {
+                    sendSuccess(res, { success: true, principleId });
+                }
+                else {
+                    sendError(res, 500, 'archive_failed', `Failed to archive principle "${principleId}"`);
+                }
+            }
+            catch (err) {
+                sendError(res, 500, 'archive_failed', err instanceof Error ? err.message : String(err));
+            }
+            return;
+        }
+        // POST /api/principles/:id/unarchive
+        const unarchiveMatch = /^\/([^/]*)\/unarchive$/.exec(subPath);
+        if (unarchiveMatch) {
+            const [, rawPrincipleId] = unarchiveMatch;
+            if (!rawPrincipleId) {
+                sendError(res, 400, 'invalid_principle_id', 'Principle ID is missing');
+                return;
+            }
+            let principleId;
+            try {
+                principleId = decodeURIComponent(rawPrincipleId);
+            }
+            catch {
+                sendError(res, 400, 'invalid_principle_id', 'Principle ID contains invalid URL encoding');
+                return;
+            }
+            try {
+                const ok = await model.unarchivePrinciple(principleId);
+                if (ok) {
+                    sendSuccess(res, { success: true, principleId });
+                }
+                else {
+                    sendError(res, 500, 'unarchive_failed', `Failed to unarchive principle "${principleId}"`);
+                }
+            }
+            catch (err) {
+                sendError(res, 500, 'unarchive_failed', err instanceof Error ? err.message : String(err));
+            }
+            return;
+        }
+        sendNotFound(res, `Route ${req.method} /api/principles${subPath} not found`);
+        return;
+    }
+    // ── GET Routes ──────────────────────────────────────────────────────────────
     if (req.method !== 'GET') {
         sendNotFound(res, `Route /api/principles${subPath} not found`);
         return;
     }
-    const model = getModel(workspaceDir);
     if (subPath === '' || subPath === '/') {
         try {
             // Parse query string for filter parameter

package/console/dist/server/routes/update.d.ts

@@ -3,7 +3,6 @@
  *
  * GET  /check    — Check for updates
  * POST /apply    — Apply an update
- * GET  /status   — Get current update status
  * POST /rollback — Rollback an update
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';

package/console/dist/server/routes/update.js

@@ -183,6 +183,11 @@ async function doCheckForUpdates(currentVersion) {
         return {
             hasUpdate: false,
             currentVersion,
+            // Contract with the UI (UpdatePage.tsx) requires latestVersion to be a
+            // string. When the registry check fails we don't know the latest version,
+            // so emit an empty string to keep the response shape stable and let the
+            // UI surface `error` instead of crashing the whole page.
+            latestVersion: '',
             error: error instanceof Error ? error.message : 'Unknown error',
         };
     }
@@ -369,9 +374,17 @@ export async function handleUpdateRoute(req, res, workspaceDir, subPath) {
             return;
         }
         try {
+            // ERR-002 / Runtime Contract Rule 9: 当无法确定当前版本时（如插件未安装），
+            // 返回 degraded 状态 + reason，而非 500。前端 validateUpdateStatus 要求
+            // currentVersion/latestVersion 为 string，hasUpdate 为 boolean。
             const currentVersion = readCurrentVersion(pluginDir);
             if (!currentVersion) {
-                sendError(res, 500, 'version_not_found', 'Could not determine current version');
+                sendSuccess(res, {
+                    hasUpdate: false,
+                    currentVersion: 'unknown',
+                    latestVersion: '',
+                    error: 'Could not determine current version (plugin not installed)',
+                });
                 return;
             }
             const result = await doCheckForUpdates(currentVersion);
@@ -427,16 +440,6 @@ export async function handleUpdateRoute(req, res, workspaceDir, subPath) {
         }
         return;
     }
-    // GET /status
-    if (subPath === '/status') {
-        if (req.method !== 'GET') {
-            sendMethodNotAllowed(res);
-            return;
-        }
-        const currentVersion = readCurrentVersion(pluginDir) ?? 'unknown';
-        sendSuccess(res, { checking: false, updating: false, currentVersion });
-        return;
-    }
     // POST /rollback
     if (subPath === '/rollback') {
         if (req.method !== 'POST') {

package/console/dist/types.d.ts

@@ -82,5 +82,6 @@ export type ApiResponse<T> = {
 } | {
     success: false;
     error: string;
+    reason?: string;
     nextAction?: string;
 };

package/console/dist/ui/App.js

@@ -22,6 +22,7 @@ import { ControlCenterPage } from "./pages/control-center/ControlCenterPage.js";
 import { SettingsPage } from "./pages/settings/SettingsPage.js";
 import { UpdatePage } from "./pages/settings/UpdatePage.js";
 import { ReportProblemPage } from "./pages/report-problem/ReportProblemPage.js";
+import { IntentPage } from "./pages/intent/IntentPage.js";
 import { DesignSystemPage } from "./pages/design-system/DesignSystemPage.js";
 // Vite replaces import.meta.env.DEV with a boolean literal at build time.
 // The cast avoids TS2339 without needing a generated .d.ts file.
@@ -37,65 +38,6 @@ function AuthRoutes() {
     useEffect(() => {
         verifyAuth();
     }, [verifyAuth]);
-    useEffect(() => {
-        if (authed !== true)
-            return;
-        const handleKeyDown = (e) => {
-            console.log('handleKeyDown event:', e.key, 'altKey:', e.altKey);
-            if (!e.altKey)
-                return;
-            const target = e.target;
-            if (target &&
-                (target.tagName === "INPUT" ||
-                    target.tagName === "TEXTAREA" ||
-                    target.tagName === "SELECT" ||
-                    target.isContentEditable)) {
-                console.log('handleKeyDown ignored: input focused');
-                return;
-            }
-            let targetPath = null;
-            switch (e.key) {
-                case "3":
-                    targetPath = "/focus";
-                    break;
-                case "4":
-                    targetPath = "/pain";
-                    break;
-                case "5":
-                    targetPath = "/principles";
-                    break;
-                case "6":
-                    targetPath = "/activation";
-                    break;
-                case "7":
-                    targetPath = "/debt";
-                    break;
-                case "8":
-                    targetPath = "/control-center";
-                    break;
-                case "9":
-                    targetPath = "/report-problem";
-                    break;
-                case "0":
-                    targetPath = "/settings";
-                    break;
-                default:
-                    console.log('handleKeyDown: key mismatch:', e.key);
-                    return;
-            }
-            if (targetPath) {
-                console.log('handleKeyDown navigating to:', targetPath);
-                e.preventDefault();
-                navigate(targetPath);
-            }
-        };
-        console.log('Registering handleKeyDown listener');
-        window.addEventListener("keydown", handleKeyDown);
-        return () => {
-            console.log('Removing handleKeyDown listener');
-            window.removeEventListener("keydown", handleKeyDown);
-        };
-    }, [authed, navigate]);
     useEffect(() => {
         if (!showSplash)
             return;
@@ -125,7 +67,7 @@ function AuthRoutes() {
                         else {
                             navigate("/login", { replace: true });
                         }
-                    } }) }), _jsx(Route, { path: "/login", element: _jsx(LoginForm, { onAuthSuccess: handleAuthSuccess }) }), _jsx(Route, { path: "/*", element: authed === null ? (_jsx("div", { className: "min-h-screen bg-paper flex items-center justify-center", children: _jsxs("div", { className: "flex flex-col items-center gap-4", children: [_jsx("div", { className: "w-8 h-8 border-2 border-gov border-t-transparent rounded-full animate-spin" }), _jsx("span", { className: "text-[12px] font-mono tracking-wider text-ink-3 uppercase", children: "Verifying Session..." })] }) })) : authed ? (_jsx(NotificationProvider, { children: _jsxs("div", { className: "min-h-screen bg-paper text-ink", children: [_jsx("a", { href: "#main-content", className: "sr-only focus:not-sr-only focus:absolute focus:z-50 focus:p-4 focus:bg-paper focus:text-ink", children: "Skip to main content" }), _jsx(AppSidebar, {}), _jsx("main", { id: "main-content", className: "ml-[256px] min-h-screen overflow-y-auto", children: _jsx(ErrorBoundary, { children: _jsxs(Routes, { children: [_jsx(Route, { path: "/", element: _jsx(Navigate, { to: "/focus", replace: true }) }), _jsx(Route, { path: "/focus", element: _jsx(FocusPage, {}) }), _jsx(Route, { path: "/pain", element: _jsx(PainPage, {}) }), _jsx(Route, { path: "/principles", element: _jsx(PrinciplesPage, {}) }), _jsx(Route, { path: "/principles/:id", element: _jsx(PrincipleDetailPage, {}) }), _jsx(Route, { path: "/activation", element: _jsx(ActivationPage, {}) }), _jsx(Route, { path: "/debt", element: _jsx(DebtPage, {}) }), _jsx(Route, { path: "/control-center", element: _jsx(ControlCenterPage, {}) }), _jsx(Route, { path: "/settings", element: _jsx(SettingsPage, {}) }), _jsx(Route, { path: "/update", element: _jsx(UpdatePage, {}) }), _jsx(Route, { path: "/report-problem", element: _jsx(ReportProblemPage, {}) }), IS_DEV && (_jsx(Route, { path: "/design-system", element: _jsx(DesignSystemPage, {}) })), !IS_DEV && (_jsx(Route, { path: "/design-system", element: _jsx(Navigate, { to: "/focus", replace: true }) }))] }) }) })] }) })) : (_jsx(Navigate, { to: "/login", replace: true })) })] }));
+                    } }) }), _jsx(Route, { path: "/login", element: _jsx(LoginForm, { onAuthSuccess: handleAuthSuccess }) }), _jsx(Route, { path: "/*", element: authed === null ? (_jsx("div", { className: "min-h-screen bg-paper flex items-center justify-center", children: _jsxs("div", { className: "flex flex-col items-center gap-4", children: [_jsx("div", { className: "w-8 h-8 border-2 border-gov border-t-transparent rounded-full animate-spin" }), _jsx("span", { className: "text-[12px] font-mono tracking-wider text-ink-3 uppercase", children: "Verifying Session..." })] }) })) : authed ? (_jsx(NotificationProvider, { children: _jsxs("div", { className: "min-h-screen bg-paper text-ink", children: [_jsx("a", { href: "#main-content", className: "sr-only focus:not-sr-only focus:absolute focus:z-50 focus:p-4 focus:bg-paper focus:text-ink", children: "Skip to main content" }), _jsx(AppSidebar, {}), _jsx("main", { id: "main-content", className: "ml-[256px] min-h-screen overflow-y-auto", children: _jsx(ErrorBoundary, { children: _jsxs(Routes, { children: [_jsx(Route, { path: "/", element: _jsx(Navigate, { to: "/focus", replace: true }) }), _jsx(Route, { path: "/focus", element: _jsx(FocusPage, {}) }), _jsx(Route, { path: "/pain", element: _jsx(PainPage, {}) }), _jsx(Route, { path: "/principles", element: _jsx(PrinciplesPage, {}) }), _jsx(Route, { path: "/principles/:id", element: _jsx(PrincipleDetailPage, {}) }), _jsx(Route, { path: "/activation", element: _jsx(ActivationPage, {}) }), _jsx(Route, { path: "/debt", element: _jsx(DebtPage, {}) }), _jsx(Route, { path: "/control-center", element: _jsx(ControlCenterPage, {}) }), _jsx(Route, { path: "/settings", element: _jsx(SettingsPage, {}) }), _jsx(Route, { path: "/update", element: _jsx(UpdatePage, {}) }), _jsx(Route, { path: "/report-problem", element: _jsx(ReportProblemPage, {}) }), _jsx(Route, { path: "/intent", element: _jsx(IntentPage, {}) }), IS_DEV && (_jsx(Route, { path: "/design-system", element: _jsx(DesignSystemPage, {}) })), !IS_DEV && (_jsx(Route, { path: "/design-system", element: _jsx(Navigate, { to: "/focus", replace: true }) }))] }) }) })] }) })) : (_jsx(Navigate, { to: "/login", replace: true })) })] }));
 }
 export function App() {
     return (_jsx(ThemeProvider, { children: _jsxs(I18nextProvider, { i18n: i18n, children: [_jsx(HashRouter, { children: _jsx(AuthRoutes, {}) }), _jsx(Toaster, {})] }) }));

package/console/dist/ui/api.d.ts

@@ -1,22 +1,8 @@
 import type { ApiResponse } from "../types.js";
-import type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, OutputLanguageData, GovernanceQueueData, ActivationsData, DisableActivationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, RollbackResultData, ApprovalRecordData, PrinciplesListData, ApprovalsGroupedData, EvidenceChainData, TrajectoryData } from "./utils/validators.js";
+import type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, FeatureFlagUpdateData, OutputLanguageData, GovernanceQueueData, ActivationsData, DisableActivationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, RollbackResultData, ApprovalRecordData, PrinciplesListData, ApprovalsGroupedData, EvidenceChainData, TrajectoryData, IntentSummaryData, IntentDecisionRecordData, IntentDecisionResultData, IntentDecisionSummaryData, FollowUpResponseData, IntentInitResultData, IntentSaveResultData, IntentRawContentData, IntentVersionData } from "./utils/validators.js";
 declare function getToken(): string | null;
 declare function setToken(token: string): void;
 declare function clearToken(): void;
-/**
- * Send an authenticated request to the Console API.
- *
- * Two overloads:
- * 1. request(path, options?) → ApiResponse<unknown>
- *    For endpoints without a runtime validator (health checks, etc.).
- *    The caller receives unvalidated data and must not assume a specific shape.
- *
- * 2. request<T>(path, options, validate) → ApiResponse<T>
- *    For endpoints with a runtime validator. The validator is applied to the
- *    raw response; if validation fails, returns an error envelope instead.
- */
-declare function request(path: string, options?: RequestInit): Promise<ApiResponse<unknown>>;
-declare function request<T>(path: string, options: RequestInit | undefined, validate: (value: unknown) => T | null): Promise<ApiResponse<T>>;
 declare function checkAuth(): Promise<boolean>;
 declare function fetchWorkspaces(): Promise<ApiResponse<WorkspaceEntryData[]>>;
 declare function addWorkspace(name: string, path: string): Promise<ApiResponse<WorkspaceEntryData>>;
@@ -24,8 +10,9 @@ declare function removeWorkspace(name: string): Promise<ApiResponse<RemovedEnvel
 declare function syncWorkspace(name: string): Promise<ApiResponse<SyncResultData>>;
 declare function fetchPrinciples(filter?: 'all' | 'actionable'): Promise<ApiResponse<PrinciplesListData>>;
 declare function fetchPrincipleDetail(principleId: string): Promise<ApiResponse<unknown>>;
+declare function archivePrinciple(principleId: string): Promise<ApiResponse<unknown>>;
+declare function unarchivePrinciple(principleId: string): Promise<ApiResponse<unknown>>;
 declare function fetchPrincipleTrajectory(principleId: string): Promise<ApiResponse<TrajectoryData>>;
-declare function fetchApprovalDetail(approvalId: string): Promise<ApiResponse<ApprovalRecordData>>;
 declare function approveApproval(approvalId: string, note?: string): Promise<ApiResponse<ApprovalRecordData>>;
 declare function rejectApproval(approvalId: string, reason: string): Promise<ApiResponse<ApprovalRecordData>>;
 declare function editApproval(approvalId: string, newArtifactId: string, editReason: string): Promise<ApiResponse<ApprovalRecordData>>;
@@ -39,6 +26,7 @@ declare function fetchConfigSummary(): Promise<ApiResponse<ConfigSummaryData>>;
 declare function fetchConfigCatalog(): Promise<ApiResponse<ConfigCatalogData>>;
 declare function updateAgentBinding(agentName: string, runtimeProfile: string, enabled: boolean): Promise<ApiResponse<AgentBindingUpdateData>>;
 declare function updateDefaultRuntime(defaultRuntime: string): Promise<ApiResponse<DefaultRuntimeUpdateData>>;
+declare function patchFeatureFlag(featureName: string, enabled: boolean): Promise<ApiResponse<FeatureFlagUpdateData>>;
 declare function fetchOutputLanguage(): Promise<ApiResponse<OutputLanguageData>>;
 declare function updateOutputLanguage(outputLanguage: string): Promise<ApiResponse<OutputLanguageData>>;
 declare function fetchGovernanceQueue(): Promise<ApiResponse<GovernanceQueueData>>;
@@ -51,8 +39,60 @@ declare function fetchUpdateHistory(): Promise<ApiResponse<UpdateHistoryData>>;
 declare function applyUpdate(): Promise<ApiResponse<ApplyUpdateResultData>>;
 declare function rollbackUpdate(backupDir: string): Promise<ApiResponse<RollbackResultData>>;
 declare function fetchEvidenceChain(): Promise<ApiResponse<EvidenceChainData>>;
-export { getToken, setToken, clearToken, checkAuth, request, fetchApprovalDetail, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchPrincipleDetail, fetchPrincipleTrajectory, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchApprovalsGrouped, fetchAllActivations, disableActivation, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyUpdate, rollbackUpdate, fetchEvidenceChain, };
-export type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, OutputLanguageData, GovernanceQueueData, ActivationsData, DisableActivationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, RollbackResultData, ApprovalRecordData, PrinciplesListData, ApprovalsGroupedData, EvidenceChainData, EvidenceChainRecordData, EvidenceChainStateData, TrajectoryData, TrajectoryStageData, } from "./utils/validators.js";
+declare function fetchIntentSummary(lang?: 'zh-CN' | 'en'): Promise<ApiResponse<IntentSummaryData>>;
+/**
+ * Fetch raw INTENT.md content for editing via GET /api/v1/intent/content.
+ */
+declare function fetchIntentContent(lang?: 'zh-CN' | 'en'): Promise<ApiResponse<IntentRawContentData>>;
+/**
+ * Create INTENT.md from the SPEC §7 template via POST /api/v1/intent/init.
+ * Does NOT overwrite an existing file unless force=true.
+ */
+declare function createIntentTemplate(force?: boolean, lang?: 'zh-CN' | 'en'): Promise<ApiResponse<IntentInitResultData>>;
+/**
+ * Save user-edited INTENT.md content via PUT /api/v1/intent/content.
+ */
+declare function saveIntentContent(content: string, lang?: 'zh-CN' | 'en'): Promise<ApiResponse<IntentSaveResultData>>;
+declare function fetchIntentVersions(lang?: 'zh-CN' | 'en'): Promise<ApiResponse<IntentVersionData>>;
+/**
+ * Frontend-friendly payload for recording an Owner decision on an intent tension.
+ * Field names match the server's `IntentDecisionInput` contract (SPEC §21.7).
+ */
+export interface IntentDecisionInputPayload {
+    id: string;
+    taskId: string;
+    source: string;
+    evidenceStrength: string;
+    relatedIntentFields: string[];
+    evidenceRefs: string[];
+    ownerAction: string;
+    painId?: string;
+    intentDocHash?: string;
+    note?: string;
+}
+declare function recordIntentDecision(payload: IntentDecisionInputPayload): Promise<ApiResponse<IntentDecisionResultData>>;
+declare function listIntentDecisionsByPainId(painId: string): Promise<ApiResponse<IntentDecisionRecordData[]>>;
+declare function listIntentDecisionsByTaskId(taskId: string): Promise<ApiResponse<IntentDecisionRecordData[]>>;
+declare function fetchIntentDecisionSummary(): Promise<ApiResponse<IntentDecisionSummaryData>>;
+/**
+ * Payload for dispatching a governed follow-up action after an Owner decision
+ * has been persisted (SPEC §22.1.4).
+ *
+ * - `link_candidate`: link an existing principle candidate to this decision.
+ *   `candidateId` is required.
+ * - `guide_rulehost`: get CLI guidance for promoting to RuleHost. No DB write.
+ * - `generate_patch_proposal`: generate a read-only Intent Patch Proposal.
+ *
+ * The server validates `type` and `candidateId` (when required); the frontend
+ * trusts the server to fail loud on invalid input (Rule 3).
+ */
+export interface FollowUpPayload {
+    type: 'link_candidate' | 'guide_rulehost' | 'generate_patch_proposal';
+    candidateId?: string;
+}
+declare function dispatchFollowUp(decisionId: string, payload: FollowUpPayload): Promise<ApiResponse<FollowUpResponseData>>;
+export { getToken, setToken, clearToken, checkAuth, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchPrincipleDetail, fetchPrincipleTrajectory, archivePrinciple, unarchivePrinciple, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchApprovalsGrouped, fetchAllActivations, disableActivation, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyUpdate, rollbackUpdate, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, };
+export type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, FeatureFlagUpdateData, OutputLanguageData, GovernanceQueueData, ActivationsData, DisableActivationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, RollbackResultData, ApprovalRecordData, PrinciplesListData, ApprovalsGroupedData, EvidenceChainData, EvidenceChainRecordData, EvidenceChainStateData, TrajectoryData, TrajectoryStageData, IntentSummaryData, IntentSectionsData, IntentDocWarningData, IntentDecisionRecordData, IntentDecisionResultData, IntentDecisionSummaryData, FollowUpResponseData, LinkCandidateFollowUpData, GuideRulehostFollowUpData, GeneratePatchProposalFollowUpData, IntentVersionEntry, IntentVersionData, } from "./utils/validators.js";
 export type { ActivationRecordData as ActivationRecord } from "./utils/validators.js";
 export type { ApprovalRecordData as ApprovalRecord } from "./utils/validators.js";
 export type { WorkspaceEntryData as WorkspaceEntry } from "./utils/validators.js";