create-principles-disciple 1.101.0 → 1.103.0

package/console/dist/server/config/pd-config-store.d.ts

@@ -13,7 +13,7 @@
  * - ERR-013: Object.hasOwn() for untrusted keys
  * - ERR-045: ANY-segment redaction for sensitive keys
  */
-import type { EffectivePdConfig, RedactedPdConfigSummary, InternalAgentName, FeatureFlagsResult } from '@principles/core/runtime-v2';
+import type { EffectivePdConfig, RedactedPdConfigSummary, InternalAgentName, RuntimeProfile, FeatureFlagsResult } from '@principles/core/runtime-v2';
 export interface ConfigLoadResultOk {
     ok: true;
     effective: EffectivePdConfig;
@@ -171,4 +171,53 @@ export type FeatureFlagUpdateResult = FeatureFlagUpdateResultOk | FeatureFlagUpd
  * - ERR-015/018/019: load-validate-merge-write-reload, no stale cache
  */
 export declare function updateFeatureFlag(workspaceDir: string, featureName: string, enabled: boolean): FeatureFlagUpdateResult;
+export interface RuntimeProfileCrudResultOk {
+    ok: true;
+    profileId: string;
+    profile: RuntimeProfile;
+}
+export interface RuntimeProfileCrudResultErr {
+    ok: false;
+    statusCode: number;
+    error: string;
+    message: string;
+    nextAction?: string;
+}
+export type RuntimeProfileCrudResult = RuntimeProfileCrudResultOk | RuntimeProfileCrudResultErr;
+/**
+ * Create a new runtime profile in .pd/config.yaml.
+ *
+ * - Rejects duplicate profile IDs (400 bad_request)
+ * - Validates profile structure (type + required fields via validatePdConfig)
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries:
+ * - ERR-001/ERR-005: No `as` bypasses; payload validated as unknown
+ * - ERR-002: Graceful degradation includes reason + nextAction
+ * - ERR-009/ERR-010: Required fields fail loud
+ * - ERR-013: Object.hasOwn() for untrusted keys
+ */
+export declare function createRuntimeProfile(workspaceDir: string, profileId: string, payload: unknown): RuntimeProfileCrudResult;
+/**
+ * Update an existing runtime profile in .pd/config.yaml.
+ *
+ * - Rejects non-existent profile (404 not_found)
+ * - Rejects type changes (400 bad_request — type change = delete + create)
+ * - Merges patch into existing profile, only known fields are persisted
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries: same as createRuntimeProfile.
+ */
+export declare function updateRuntimeProfile(workspaceDir: string, profileId: string, patch: unknown): RuntimeProfileCrudResult;
+/**
+ * Delete a runtime profile from .pd/config.yaml.
+ *
+ * - Rejects non-existent profile (404 not_found)
+ * - Rejects if profile is the defaultRuntime (400 bad_request)
+ * - Rejects if any agent binding references the profile (400 bad_request, lists agents)
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries: same as createRuntimeProfile.
+ */
+export declare function deleteRuntimeProfile(workspaceDir: string, profileId: string): RuntimeProfileCrudResult;
 export declare function checkReadiness(workspaceDir: string, agentName: string, getEnvVar?: (name: string) => string | undefined): ReadinessResult | ReadinessError;

package/console/dist/server/config/pd-config-store.js

@@ -16,7 +16,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import yaml from 'js-yaml';
-import { validatePdConfig, computeEffectivePdConfig, computeFeatureFlagsFromConfig, redactPdConfig, checkAgentRuntimeReadiness, resolveAgentRuntimeBinding, INTERNAL_AGENT_NAMES, } from '@principles/core/runtime-v2';
+import { validatePdConfig, computeEffectivePdConfig, computeFeatureFlagsFromConfig, redactPdConfig, checkAgentRuntimeReadiness, resolveAgentRuntimeBinding, INTERNAL_AGENT_NAMES, VALID_PROFILE_TYPES, } from '@principles/core/runtime-v2';
 // ── Constants ────────────────────────────────────────────────────────────────
 const PD_CONFIG_DIR = '.pd';
 const PD_CONFIG_FILENAME = 'config.yaml';
@@ -802,6 +802,369 @@ export function updateFeatureFlag(workspaceDir, featureName, enabled) {
         enabled: confirmedEnabled,
     };
 }
+/**
+ * Validate the basic structure of a runtime profile payload (type field).
+ * Full field validation is delegated to validatePdConfig after merge.
+ * Uses Object.hasOwn() for untrusted key checks (ERR-013).
+ */
+function validateProfileStructure(payload) {
+    if (!isRecord(payload)) {
+        return { ok: false, error: 'bad_request', message: 'Profile must be a JSON object with a type field' };
+    }
+    const typeRaw = Object.hasOwn(payload, 'type') ? payload.type : undefined;
+    if (typeRaw === undefined) {
+        return { ok: false, error: 'bad_request', message: `Profile missing required field: type (must be one of: ${VALID_PROFILE_TYPES.join(', ')})` };
+    }
+    if (typeof typeRaw !== 'string' || !VALID_PROFILE_TYPES.includes(typeRaw)) {
+        return { ok: false, error: 'bad_request', message: `Profile type must be one of: ${VALID_PROFILE_TYPES.join(', ')}. Got: ${String(typeRaw)}` };
+    }
+    return { ok: true, type: typeRaw };
+}
+/**
+ * Extract only known, correctly-typed fields from a profile payload.
+ * Prevents unknown fields from being persisted to .pd/config.yaml.
+ * Uses Object.hasOwn() for untrusted key checks (ERR-013).
+ */
+function extractProfileFields(payload, type) {
+    const result = { type };
+    if (Object.hasOwn(payload, 'provider') && typeof payload.provider === 'string') {
+        result.provider = payload.provider;
+    }
+    if (Object.hasOwn(payload, 'model') && typeof payload.model === 'string') {
+        result.model = payload.model;
+    }
+    if (type === 'openclaw') {
+        if (Object.hasOwn(payload, 'source') && typeof payload.source === 'string') {
+            result.source = payload.source;
+        }
+    }
+    else {
+        // pi-ai
+        if (Object.hasOwn(payload, 'apiKeyEnv') && typeof payload.apiKeyEnv === 'string') {
+            result.apiKeyEnv = payload.apiKeyEnv;
+        }
+        if (Object.hasOwn(payload, 'baseUrl') && typeof payload.baseUrl === 'string') {
+            result.baseUrl = payload.baseUrl;
+        }
+        if (Object.hasOwn(payload, 'timeoutMs') && typeof payload.timeoutMs === 'number') {
+            result.timeoutMs = payload.timeoutMs;
+        }
+        if (Object.hasOwn(payload, 'maxRetries') && typeof payload.maxRetries === 'number') {
+            result.maxRetries = payload.maxRetries;
+        }
+    }
+    return result;
+}
+/**
+ * Read raw config file preserving unknown root sections.
+ * Returns an empty record if the file does not exist.
+ * Treats parsed YAML as unknown (ERR-001).
+ */
+function readRawConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    const rawContent = fs.readFileSync(configPath, 'utf8');
+    const rawParsed = yaml.load(rawContent, { schema: yaml.JSON_SCHEMA });
+    if (isRecord(rawParsed)) {
+        return { ...rawParsed };
+    }
+    return {};
+}
+/**
+ * Create a new runtime profile in .pd/config.yaml.
+ *
+ * - Rejects duplicate profile IDs (400 bad_request)
+ * - Validates profile structure (type + required fields via validatePdConfig)
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries:
+ * - ERR-001/ERR-005: No `as` bypasses; payload validated as unknown
+ * - ERR-002: Graceful degradation includes reason + nextAction
+ * - ERR-009/ERR-010: Required fields fail loud
+ * - ERR-013: Object.hasOwn() for untrusted keys
+ */
+export function createRuntimeProfile(workspaceDir, profileId, payload) {
+    // 1. Validate profileId
+    if (typeof profileId !== 'string' || profileId.length === 0) {
+        return { ok: false, statusCode: 400, error: 'bad_request', message: 'profileId must be a non-empty string' };
+    }
+    // 2. Validate profile structure (type field)
+    const structResult = validateProfileStructure(payload);
+    if (!structResult.ok) {
+        return { ok: false, statusCode: 400, error: structResult.error, message: structResult.message };
+    }
+    // 3. Load existing config — refuse to write on malformed (rc-9)
+    const loadResult = loadPdConfig(workspaceDir);
+    if (!loadResult.ok) {
+        return {
+            ok: false,
+            statusCode: 409,
+            error: 'conflict',
+            message: `Cannot create runtime profile: existing .pd/config.yaml is malformed. Fix config errors first. Errors: ${loadResult.errors.map(e => e.reason).join('; ')}`,
+        };
+    }
+    const { effective } = loadResult;
+    // 4. Reject duplicate profile ID
+    if (Object.hasOwn(effective.config.runtimeProfiles, profileId)) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Runtime profile '${profileId}' already exists. Use PATCH to update it.`,
+            nextAction: `Use PATCH /api/v1/config/profiles/${encodeURIComponent(profileId)} to update the existing profile`,
+        };
+    }
+    // 5. Extract only known fields from payload (prevents unknown field persistence)
+    const profileRecord = extractProfileFields(payload, structResult.type);
+    // 6. Read raw config to preserve unknown sections, add new profile
+    const configPath = getPdConfigPath(workspaceDir);
+    const rawConfig = readRawConfig(configPath);
+    const profilesMap = isRecord(rawConfig.runtimeProfiles)
+        ? { ...rawConfig.runtimeProfiles }
+        : { ...effective.config.runtimeProfiles };
+    profilesMap[profileId] = profileRecord;
+    rawConfig.runtimeProfiles = profilesMap;
+    // 7. Validate the full updated config (catches missing required fields etc.)
+    const validation = validatePdConfig(rawConfig);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Profile validation failed: ${validation.errors.map(e => e.reason).join('; ')}`,
+            nextAction: 'Fix profile fields and retry',
+        };
+    }
+    // 8. Atomic write
+    try {
+        writeConfigAtomic(configPath, rawConfig);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, statusCode: 500, error: 'write_error', message: `Failed to write config: ${message}`, nextAction: 'Check disk space and file permissions for .pd/config.yaml' };
+    }
+    // 9. Return the validated profile from the config
+    // Defensive guard: Object.hasOwn() doesn't narrow TS type, so extract and verify.
+    const createdProfile = validation.value.runtimeProfiles[profileId];
+    if (!createdProfile) {
+        return { ok: false, statusCode: 500, error: 'internal_error',
+            message: `Profile '${profileId}' was written but could not be read back from config.`,
+            nextAction: 'This is a bug in PD config persistence. Please report it.' };
+    }
+    return {
+        ok: true,
+        profileId,
+        profile: createdProfile,
+    };
+}
+/**
+ * Update an existing runtime profile in .pd/config.yaml.
+ *
+ * - Rejects non-existent profile (404 not_found)
+ * - Rejects type changes (400 bad_request — type change = delete + create)
+ * - Merges patch into existing profile, only known fields are persisted
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries: same as createRuntimeProfile.
+ */
+export function updateRuntimeProfile(workspaceDir, profileId, patch) {
+    // 1. Validate profileId
+    if (typeof profileId !== 'string' || profileId.length === 0) {
+        return { ok: false, statusCode: 400, error: 'bad_request', message: 'profileId must be a non-empty string' };
+    }
+    // 2. Validate patch is a record
+    if (!isRecord(patch)) {
+        return { ok: false, statusCode: 400, error: 'bad_request', message: 'Patch payload must be a JSON object' };
+    }
+    // 3. Load existing config — refuse to write on malformed (rc-9)
+    const loadResult = loadPdConfig(workspaceDir);
+    if (!loadResult.ok) {
+        return {
+            ok: false,
+            statusCode: 409,
+            error: 'conflict',
+            message: `Cannot update runtime profile: existing .pd/config.yaml is malformed. Fix config errors first. Errors: ${loadResult.errors.map(e => e.reason).join('; ')}`,
+        };
+    }
+    const { effective } = loadResult;
+    // 4. Reject if profile doesn't exist (404)
+    if (!Object.hasOwn(effective.config.runtimeProfiles, profileId)) {
+        return {
+            ok: false,
+            statusCode: 404,
+            error: 'not_found',
+            message: `Runtime profile '${profileId}' does not exist. Available profiles: ${Object.keys(effective.config.runtimeProfiles).join(', ')}`,
+            nextAction: 'Use POST /api/v1/config/profiles to create a new profile',
+        };
+    }
+    const existingProfile = effective.config.runtimeProfiles[profileId];
+    // Defensive guard: Object.hasOwn() above doesn't narrow TS type.
+    if (!existingProfile) {
+        return { ok: false, statusCode: 500, error: 'internal_error',
+            message: `Profile '${profileId}' existence check passed but value is undefined.`,
+            nextAction: 'This is a bug in PD config resolution. Please report it.' };
+    }
+    // 5. Reject type change (type change = delete + create)
+    if (Object.hasOwn(patch, 'type')) {
+        const patchType = patch.type;
+        if (typeof patchType !== 'string' || patchType !== existingProfile.type) {
+            return {
+                ok: false,
+                statusCode: 400,
+                error: 'bad_request',
+                message: `Cannot change profile type (existing: '${existingProfile.type}', requested: '${String(patchType)}'). Type change equals delete + create. Delete this profile and create a new one instead.`,
+                nextAction: `DELETE /api/v1/config/profiles/${encodeURIComponent(profileId)} then POST /api/v1/config/profiles with the new type`,
+            };
+        }
+    }
+    // 6. Merge patch into existing profile, then extract only known fields
+    const mergedSource = { ...existingProfile, ...patch };
+    const mergedRecord = extractProfileFields(mergedSource, existingProfile.type);
+    // 7. Read raw config to preserve unknown sections, update the profile
+    const configPath = getPdConfigPath(workspaceDir);
+    const rawConfig = readRawConfig(configPath);
+    const profilesMap = isRecord(rawConfig.runtimeProfiles)
+        ? { ...rawConfig.runtimeProfiles }
+        : { ...effective.config.runtimeProfiles };
+    profilesMap[profileId] = mergedRecord;
+    rawConfig.runtimeProfiles = profilesMap;
+    // 8. Validate the full updated config
+    const validation = validatePdConfig(rawConfig);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Profile validation failed: ${validation.errors.map(e => e.reason).join('; ')}`,
+            nextAction: 'Fix profile fields and retry',
+        };
+    }
+    // 9. Atomic write
+    try {
+        writeConfigAtomic(configPath, rawConfig);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, statusCode: 500, error: 'write_error', message: `Failed to write config: ${message}`, nextAction: 'Check disk space and file permissions for .pd/config.yaml' };
+    }
+    // 10. Return the validated updated profile
+    // Defensive guard: Object.hasOwn() doesn't narrow TS type.
+    const updatedProfile = validation.value.runtimeProfiles[profileId];
+    if (!updatedProfile) {
+        return { ok: false, statusCode: 500, error: 'internal_error',
+            message: `Profile '${profileId}' was updated but could not be read back from config.`,
+            nextAction: 'This is a bug in PD config persistence. Please report it.' };
+    }
+    return {
+        ok: true,
+        profileId,
+        profile: updatedProfile,
+    };
+}
+/**
+ * Delete a runtime profile from .pd/config.yaml.
+ *
+ * - Rejects non-existent profile (404 not_found)
+ * - Rejects if profile is the defaultRuntime (400 bad_request)
+ * - Rejects if any agent binding references the profile (400 bad_request, lists agents)
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries: same as createRuntimeProfile.
+ */
+export function deleteRuntimeProfile(workspaceDir, profileId) {
+    // 1. Validate profileId
+    if (typeof profileId !== 'string' || profileId.length === 0) {
+        return { ok: false, statusCode: 400, error: 'bad_request', message: 'profileId must be a non-empty string' };
+    }
+    // 2. Load existing config — refuse to write on malformed (rc-9)
+    const loadResult = loadPdConfig(workspaceDir);
+    if (!loadResult.ok) {
+        return {
+            ok: false,
+            statusCode: 409,
+            error: 'conflict',
+            message: `Cannot delete runtime profile: existing .pd/config.yaml is malformed. Fix config errors first. Errors: ${loadResult.errors.map(e => e.reason).join('; ')}`,
+        };
+    }
+    const { effective } = loadResult;
+    // 3. Reject if profile doesn't exist (404)
+    if (!Object.hasOwn(effective.config.runtimeProfiles, profileId)) {
+        return {
+            ok: false,
+            statusCode: 404,
+            error: 'not_found',
+            message: `Runtime profile '${profileId}' does not exist. Available profiles: ${Object.keys(effective.config.runtimeProfiles).join(', ')}`,
+        };
+    }
+    // Capture the profile snapshot BEFORE deletion (for return value).
+    // Defensive guard: Object.hasOwn() doesn't narrow TS type.
+    const deletedProfile = effective.config.runtimeProfiles[profileId];
+    if (!deletedProfile) {
+        return { ok: false, statusCode: 500, error: 'internal_error',
+            message: `Profile '${profileId}' existence check passed but value is undefined.`,
+            nextAction: 'This is a bug in PD config resolution. Please report it.' };
+    }
+    // 4. Reject if profile is the defaultRuntime
+    if (effective.config.internalAgents.defaultRuntime === profileId) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Cannot delete runtime profile '${profileId}' because it is the default runtime. Change the default runtime first.`,
+            nextAction: 'Use PATCH /api/v1/config/default-runtime to change the default to another profile before deleting',
+        };
+    }
+    // 5. Reject if any agent binding references this profile (list the agents)
+    const referencingAgents = [];
+    for (const agentName of INTERNAL_AGENT_NAMES) {
+        const binding = effective.config.internalAgents.agents[agentName];
+        if (binding && binding.runtimeProfile === profileId) {
+            referencingAgents.push(agentName);
+        }
+    }
+    if (referencingAgents.length > 0) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Cannot delete runtime profile '${profileId}' because it is referenced by agents: ${referencingAgents.join(', ')}. Update their bindings first.`,
+            nextAction: `Use PATCH /api/v1/config/agents/:agentName/binding to reassign: ${referencingAgents.join(', ')}`,
+        };
+    }
+    // 6. Read raw config to preserve unknown sections, remove the profile
+    const configPath = getPdConfigPath(workspaceDir);
+    const rawConfig = readRawConfig(configPath);
+    const profilesMap = isRecord(rawConfig.runtimeProfiles)
+        ? { ...rawConfig.runtimeProfiles }
+        : {};
+    delete profilesMap[profileId];
+    rawConfig.runtimeProfiles = profilesMap;
+    // 7. Validate the updated config
+    const validation = validatePdConfig(rawConfig);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Updated config would be invalid after deletion: ${validation.errors.map(e => e.reason).join('; ')}`,
+        };
+    }
+    // 8. Atomic write
+    try {
+        writeConfigAtomic(configPath, rawConfig);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, statusCode: 500, error: 'write_error', message: `Failed to write config: ${message}`, nextAction: 'Check disk space and file permissions for .pd/config.yaml' };
+    }
+    // 9. Return the deleted profile snapshot for client confirmation
+    return {
+        ok: true,
+        profileId,
+        profile: deletedProfile,
+    };
+}
 // ── Check Readiness ──────────────────────────────────────────────────────────
 export function checkReadiness(workspaceDir, agentName, getEnvVar = (name) => process.env[name]) {
     // 1. Validate agent name

package/console/dist/server/index.js

@@ -17,6 +17,7 @@ import { handleGovernanceRoute, disposeGovernanceModels } from './routes/governa
 import { handleEvidenceChainRoute, disposeEvidenceChainModels } from './routes/evidence-chain.js';
 import { handleIntentRoute, disposeIntentModels } from './routes/intent.js';
 import { handleIntentDecisionsRoute, disposeIntentDecisionModels } from './routes/intent-decisions.js';
+import { handleOnboardingRoute, disposeOnboardingModels } from './routes/onboarding.js';
 import { createWorkspacesRoutes } from './routes/workspaces.js';
 import { handleUpdateRoute } from './routes/update.js';
 import { handleUpdateHistoryRoute } from './routes/update-history.js';
@@ -229,6 +230,7 @@ async function closeServices() {
     disposeEvidenceChainModels();
     disposeIntentModels();
     disposeIntentDecisionModels();
+    disposeOnboardingModels();
 }
 // ── Route handler ───────────────────────────────────────────────────────────
 function handleRequest(services) {
@@ -340,6 +342,13 @@ function handleRequest(services) {
                 asyncHandler(() => handleIntentDecisionsRoute(req, res, services.workspaceDir, subPath))(req, res);
                 return;
             }
+            // Onboarding wizard: POST /api/v1/onboarding/run-demo — spawns `pd demo story-a`
+            // (spec 2026-06-30-new-user-onboarding-design.md §6.3 改动 5)
+            if (urlPath === '/api/v1/onboarding' || urlPath.startsWith('/api/v1/onboarding/')) {
+                const subPath = urlPath === '/api/v1/onboarding' ? '' : urlPath.slice('/api/v1/onboarding'.length);
+                asyncHandler(() => handleOnboardingRoute(req, res, { workspaceDir: services.workspaceDir, subPath }))(req, res);
+                return;
+            }
             // PRI-331: GET /api/v1/evidence-chain
             if (urlPath === '/api/v1/evidence-chain') {
                 asyncHandler(() => handleEvidenceChainRoute(req, res, services.workspaceDir))(req, res);

package/console/dist/server/models/ActivationsConsoleModel.d.ts

@@ -1,18 +1,57 @@
+/**
+ * PRI-491 — owner-observable activation record.
+ *
+ * Mirrors the CLI's `AnnotatedActivation` so the Console surfaces the same
+ * mode / status / contextVersion / evidenceRefs / nextAction fields the owner
+ * sees in `pd activation list`. Without this enrichment the Console would
+ * hide suspended-by-flag state, silently showing v2 activations as "active"
+ * even when the rulecode_context_v2 flag is off.
+ */
 export interface ActivationRecord {
-    id: string;
+    activationId: string;
     artifactId: string;
     principleId: string;
     channel: string;
     action: string;
     targetRef: string;
     activatedAt: string | null;
-    status: 'active' | 'inactive';
+    /** When this activation was promoted from shadow to live (null for never-promoted). */
+    promotedAt: string | null;
+    /** When this activation was deactivated (null for active). */
+    deactivatedAt: string | null;
+    /**
+     * Lifecycle mode derived from action.
+     * - 'shadow' for code_tool_hook_shadow_activate
+     * - 'live'   for code_tool_hook_live_activate
+     * - undefined for unrecognized actions (cannot be safely mode-tagged).
+     */
+    mode?: 'shadow' | 'live';
+    /**
+     * Owner-visible status. Precedence: deactivated > suspended_by_flag > active.
+     * - 'deactivated'      — deactivatedAt is non-null.
+     * - 'suspended_by_flag' — v2 artifact but rulecode_context_v2 flag is off.
+     * - 'active'           — loaded and (for v2) flag is on.
+     */
+    status: 'active' | 'deactivated' | 'suspended_by_flag';
+    /** Artifact context version derived from requiresContextVersion field. */
+    contextVersion?: 'v1' | 'v2';
+    /** Owner-labelled evidence refs preserved from the artifact (PRI-490). */
+    evidenceRefs?: string[];
+    /** Human-readable summary of evidenceRefs for display. */
+    evidenceSummary?: string;
+    /** Next CLI command the owner should run to act on this activation. */
+    nextAction?: string;
+    /** Present when the activation references a non-existent artifact. */
+    warning?: string;
 }
 export interface ActivationsResponse {
     activations: ActivationRecord[];
-    generatedAt: string;
-    /** Present when data is degraded/missing rather than genuinely empty */
-    note?: string;
+    /** 'ok' on success, 'degraded' when data is incomplete/missing. */
+    status: 'ok' | 'degraded';
+    /** Present when status is 'degraded' — explains why. */
+    reason?: string;
+    /** Present when status is 'degraded' — next operator action. */
+    nextAction?: string;
 }
 export declare class ActivationsConsoleModel {
     private readonly workspaceDir;