@lesliechan721/aw 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/src/tui/controller.d.ts

@@ -1,14 +1,164 @@
-import type { CatalogSource, PlatformName, Scope } from '../types.js';
-import type { PortableReview } from '../portable/commands.js';
+import type { CatalogActivationMode, CatalogSource, CatalogGenerationActiveV1, CatalogGenerationCandidateEvidence, CatalogGenerationSyncResult, CatalogSourceImpact, DependencyScopeOverride, PlatformName, Scope } from '../types.js';
+import type { PortableReview, PortableInstallReceipt, PortableRetryReview } from '../portable/commands.js';
 import type { CatalogSourceUpdate } from '../utils/catalog-sources.js';
-import type { StatusV4Payload, StatusV4PluginSummary } from '../commands/status-v4.js';
-import type { ProjectConfigStoreLayer } from '../utils/plugin-config.js';
-import type { DependencyOperationPlan } from '../commands/dependency-operation-plan.js';
+import type { CatalogGenerationFreshnessState, CatalogGenerationFreshnessResult } from '../utils/catalog-generation-service.js';
+import type { StatusV8Payload, StatusV8PluginSummary, StatusScopedTarget, StatusTargetRevision } from '../commands/status-v6.js';
+import type { ReconcileOperationPlan } from '../commands/reconcile-operation-plan.js';
+import type { PreApplyAuthorizationTarget, RebuildCommandResult } from '../commands/rebuild-command.js';
+import type { OfflineCleanupTargetEvidence } from '../commands/offline-cleanup-evidence.js';
+import type { CodexReconcilePlan } from '../utils/codex-reconciler.js';
+import type { OperationPlan } from '../commands/operation-plan.js';
 import type { RebuildProgressFeed, RebuildProgressSnapshot } from '../output/rebuild-progress.js';
-import { type ConfigPageViewModel, type ConfigGroupViewModel, type PluginListItemViewModel, type PluginDependencyOverviewViewModel, type PortableSkillSelectionViewModel, type SourceHealthViewModel, type SourceDetailViewModel, type TuiViewModel, type UserIssueCategory, type UserIssueViewModel } from './model.js';
-import { type PortableBlockerCode, type TuiPageContext, type TuiRoute, type TuiRouterSnapshot } from './router.js';
-export type PluginWriteOperation = 'install' | 'upgrade' | 'reinstall' | 'uninstall' | 'cleanup';
+import { type ConfigPageViewModel, type ConfigGroupViewModel, type InstallPlacementDraftViewModel, type PluginListItemViewModel, type PluginDependencyOverviewViewModel, type PortableSkillSelectionViewModel, type SourceHealthViewModel, type SourceDetailViewModel, type TuiViewModel, type UserIssueCategory, type UserIssueViewModel } from './model.js';
+import type { PluginContentOverview } from './plugin-content.js';
+import { type PluginDetailSubject } from './plugin-detail.js';
+import { OperationHistoryStore, type OperationDiagnosticDetail, type OperationEffectFacts, type OperationHistorySummary, type OperationReportPreview, type SafeOperationDiagnostic, type SaveOperationReportResult } from './operation-history.js';
+import { type ProjectInventoryRoot, type ProjectInventoryViewModel } from './project-inventory.js';
+import { type ConfigInvalidStoreEvidence, type PluginInstallFilter, type PortableBlockerCode, type TuiPageContext, type TuiRoute, type TuiRouterSnapshot } from './router.js';
+import { type CatalogSourceGenerationViewModel } from './catalog-generation.js';
+import type { CatalogSourceFreshnessViewModel } from './catalog-freshness.js';
+import type { CatalogSessionReusableCandidate } from './catalog-sources/types.js';
+import type { CatalogStoreStatusResult } from '../commands/catalog-store.js';
+import type { CatalogStoreTaskEvidence } from './catalog-store-task.js';
+import { type PluginWriteTaskBlockedTarget, type PluginWriteTaskCandidate, type PluginWriteTaskCause, type PluginWriteTaskGoal, type PluginWriteTaskIntent, type PluginWriteTaskTarget } from './plugin-write-task.js';
+export type { PluginWriteTaskBlockReason, PluginWriteTaskCandidate, PluginWriteTaskExpectedUpdate, PluginWriteTaskGoal, PluginWriteTaskIntent, PluginWriteTaskMethod, PluginWriteTaskTarget, } from './plugin-write-task.js';
+type CatalogActivationBlockReason = 'configDraft' | 'sourceDraft' | 'batchDraft' | 'portableDraft' | 'activeReview' | 'reviewPreparation' | 'writeProgress';
+export interface ExternalDraftState {
+    kind: 'configDraft' | 'sourceDraft' | 'batchDraft';
+    owner: string;
+    flowId?: string;
+    revision: number;
+}
+export type PluginWriteOperation = 'install' | 'refreshAndSync' | 'reinstall' | 'uninstall' | 'cleanup' | 'sync';
+export declare const PLUGIN_WRITE_BATCH_ACTIONS: readonly ["install", "sync", "reinstall", "uninstall", "cleanup"];
+export type BatchPluginWriteAction = typeof PLUGIN_WRITE_BATCH_ACTIONS[number];
+export type PluginWriteBatchSelection = {
+    kind: 'selected';
+    pluginIds: string[];
+} | {
+    kind: 'targets';
+    targets: PluginWriteBatchTarget[];
+} | {
+    kind: 'currentProjectIntentTargets';
+    targets: PluginWriteBatchTarget[];
+} | {
+    kind: 'currentProjectIntentRoots';
+};
+export interface PluginWriteBatchTarget {
+    pluginId: string;
+    platform: PlatformName;
+    scope: Scope;
+}
+export interface PluginInstallBatchTarget extends PluginWriteBatchTarget {
+    state: 'add' | 'existing' | 'blocked';
+    reason?: string;
+}
+export declare function pluginWriteBatchTargets(action: Exclude<BatchPluginWriteAction, 'install'>, pluginIds: readonly string[], statusTargets: readonly StatusScopedTarget[]): PluginWriteBatchTarget[];
+export interface PluginWriteBatchIntent {
+    kind: 'pluginWriteBatch';
+    dependencyScopeOverrides?: DependencyScopeOverride[];
+    action: BatchPluginWriteAction;
+    selection: PluginWriteBatchSelection;
+    platform: PlatformName | 'both';
+    scope: Scope;
+    scriptTimeoutMs?: number;
+}
+export interface PluginWriteBatchGroupEvidence {
+    groupId: string;
+    sourceId: string;
+    platform: PlatformName | 'both';
+    scope: Scope;
+    requestedPluginIds: string[];
+    preview: RebuildCommandResult;
+    executable: boolean;
+}
+export interface PluginWriteBatchEvidence extends OperationEvidence {
+    requestedPluginIds: string[];
+    groups: PluginWriteBatchGroupEvidence[];
+    projectIntentDigest?: string;
+    targetVersions?: Array<PluginWriteBatchTarget & {
+        presence: 'new' | 'installed' | 'unknown';
+        installedVersion?: string;
+        availableVersion?: string;
+    }>;
+}
+export interface PluginWriteBatchGroupResult {
+    groupId: string;
+    sourceId: string;
+    platform: PlatformName | 'both';
+    scope: Scope;
+    requestedPluginIds: string[];
+    result: RebuildCommandResult;
+}
+export interface PluginWriteBatchExecutionResult extends RebuildCommandResult {
+    requestedPluginIds: string[];
+    groupResults: PluginWriteBatchGroupResult[];
+}
+export interface PluginWriteTaskSourceEvidence {
+    sourceId: string;
+    sourceIdentity: string;
+    requestedTargets: PluginWriteTaskTarget[];
+    causes: PluginWriteTaskCause[];
+    preview: RebuildCommandResult;
+    executable: boolean;
+}
+export interface PluginWriteTaskEvidence extends OperationEvidence {
+    taskPlan: {
+        goal: PluginWriteTaskGoal;
+        requestedTargets: PluginWriteTaskTarget[];
+        executableTargets: PluginWriteTaskTarget[];
+        causes: PluginWriteTaskCause[];
+        blockedTargets: PluginWriteTaskBlockedTarget[];
+        sources: PluginWriteTaskSourceEvidence[];
+        targetFingerprint: string;
+        planFingerprint: string;
+    };
+}
+export interface PluginWriteTaskSourceResult {
+    sourceId: string;
+    sourceIdentity: string;
+    requestedTargets: PluginWriteTaskTarget[];
+    result: RebuildCommandResult;
+}
+export interface PluginWriteTaskExecutionResult extends RebuildCommandResult {
+    taskPlan: PluginWriteTaskEvidence['taskPlan'];
+    sourceResults: PluginWriteTaskSourceResult[];
+}
 export type OperationKind = OperationIntent['kind'];
+export interface ConfigOperationChange {
+    key: string;
+    title: string;
+    before: string;
+    after: string;
+    children?: Array<{
+        property: string;
+        before: string;
+        after: string;
+        private?: boolean;
+    }>;
+}
+export interface ConfigSaveBatchGroup {
+    editEvidence?: Record<string, import('./model.js').ConfigEditEvidence>;
+    scope: Scope;
+    updates?: Record<string, unknown>;
+    removeKeys?: string[];
+    sensitiveKeys?: string[];
+    privateKeys?: string[];
+    changes?: ConfigOperationChange[];
+}
+export interface ConfigSaveBatchGroupResult {
+    scope: Scope;
+    status: 'succeeded' | 'failed';
+    configSaved: boolean;
+    applyRequested: boolean;
+    applyStatus: 'notRequested' | 'notNeeded' | 'succeeded' | 'failed';
+    errorCode?: string;
+    execution?: unknown;
+}
+export interface ConfigSaveBatchExecutionResult {
+    status: 'succeeded' | 'partial' | 'failed';
+    groups: ConfigSaveBatchGroupResult[];
+}
 export interface IssueOrigin {
     issueId: string;
     issueKey: string;
@@ -29,34 +179,51 @@ export type OperationIntent = {
     pluginId: string;
     platform: PlatformName | 'both';
     scope: Scope;
+    dependencyScopeOverrides?: DependencyScopeOverride[];
+    expectedUpdate?: {
+        installedVersion: string;
+        activeVersion: string;
+        sourceIdentity: string;
+        generationKey: string;
+    };
+    recoveryDescription?: string;
     force?: boolean;
+    scriptTimeoutMs?: number;
     originIssue?: IssueOrigin;
-} | {
+} | PluginWriteBatchIntent | PluginWriteTaskIntent | {
     kind: 'portableInstall';
     pluginId: string;
     scope: Scope;
     selectedSkills: string[];
     requestedAgents?: string[];
+    retry?: {
+        receipt: PortableInstallReceipt;
+        review?: PortableRetryReview;
+    };
 } | {
     kind: 'configSave';
     pluginId: string;
     scope: Scope;
-    projectLayer: ProjectConfigStoreLayer;
+    apply: boolean;
+    scriptTimeoutMs?: number;
+    retryApply?: true;
     updates?: Record<string, unknown>;
     removeKeys?: string[];
     sensitiveKeys?: string[];
     privateKeys?: string[];
-    changes?: Array<{
-        key: string;
-        title: string;
-        before: string;
-        after: string;
-    }>;
+    changes?: ConfigOperationChange[];
+} | {
+    kind: 'configSaveBatch';
+    pluginId: string;
+    apply: boolean;
+    scriptTimeoutMs?: number;
+    groups: ConfigSaveBatchGroup[];
 } | {
     kind: 'configReset';
     pluginId: string;
     scope: Scope;
-    projectLayer: ProjectConfigStoreLayer;
+    expectedStoreState?: 'invalid';
+    changes?: ConfigOperationChange[];
 } | {
     kind: 'sourceMutation';
     action: 'add' | 'update' | 'setPrimary' | 'remove';
@@ -69,43 +236,132 @@ export type OperationIntent = {
         after?: string;
         private?: boolean;
     }>;
+} | {
+    kind: 'catalogGeneration';
+    action: 'activate' | 'update' | 'repair' | 'replaceDamaged' | 'recoverState';
+    sourceId: string;
+    sourceMutation?: {
+        action: 'add';
+        source: CatalogSource;
+    } | {
+        action: 'update';
+        update: CatalogSourceUpdate;
+    };
+    setPrimaryAfterActivation?: boolean;
+} | {
+    kind: 'catalogSourcesRecovery';
+} | {
+    kind: 'catalogStorePrune';
 };
+export interface ConfigOperationEvidence {
+    scope: Scope;
+    schemaIdentity?: string;
+    storeDigest: string;
+    impactState?: 'known' | 'unknown';
+    noEffectiveChange?: true;
+    affectedTargets: Array<{
+        platform: PlatformName;
+        scope: Scope;
+    }>;
+    preApplyAuthorization?: PreApplyAuthorizationTarget[];
+    sharedNativeRenderTargets?: Array<{
+        id: string;
+        skillKey: string;
+        refreshKeys: string[];
+    }>;
+    shareability?: 'verified' | 'unverified';
+}
 export interface OperationEvidence {
     catalog: {
         configDigest: string;
         compositeDigest: string;
+        generationSetDigest?: string;
     };
     source?: {
         sourceId: string;
         sourceIdentity: string;
+        logicalIdentity?: string;
         requestedRef?: string;
         resolvedCommit?: string;
         manifestDigest?: string;
         snapshotDigest?: string;
         contentDigest?: string;
+        pluginVersion?: string;
+        catalogVersion?: string;
+        channel?: 'latest' | 'beta';
     };
     targetFingerprint?: string;
-    dependencyPlan?: DependencyOperationPlan;
-    config?: {
+    offlineCleanup?: OfflineCleanupTargetEvidence;
+    offlineCleanupPlans?: OfflineCleanupTargetEvidence[];
+    removedPluginCleanupIds?: string[];
+    dependencyPlan?: ReconcileOperationPlan;
+    codexReconcilePlans?: CodexReconcilePlan[];
+    operationPlan?: OperationPlan;
+    preparationWarnings?: string[];
+    codexManager?: {
+        state: 'system' | 'cached' | 'requires-install';
+        packageName: '@openai/codex';
+        version: string;
+    };
+    config?: ConfigOperationEvidence;
+    configBatch?: {
+        groups: Array<{
+            scope: Scope;
+            config: ConfigOperationEvidence;
+            targetFingerprint: string;
+        }>;
+    };
+    resetTarget?: {
+        sourceId: string;
+        pluginName: string;
         scope: Scope;
-        projectLayer: ProjectConfigStoreLayer;
-        schemaIdentity?: string;
-        storeDigest: string;
+        kind: 'absent' | 'regularFile' | 'symbolicLink' | 'directory';
+        fingerprint: string;
     };
     sourceWrite?: {
         configDigest: string;
-        candidateDigest: string;
+        proposedConfigDigest: string;
         sourceIdentity?: string;
         inventoryDigest: string;
+        impactDigest?: string;
         referenceCount: number;
         inventoryComplete: boolean;
+        impact?: CatalogSourceImpact;
+    };
+    catalogGeneration?: {
+        action: Extract<OperationIntent, {
+            kind: 'catalogGeneration';
+        }>['action'];
+        previousActive?: CatalogGenerationActiveV1;
+        previousActiveVersion?: string;
+        candidate: CatalogGenerationCandidateEvidence;
+        candidateRelation?: CatalogGenerationFreshnessState;
+        explicitSourceChange?: boolean;
+        exactRepair?: boolean;
+        activationMode?: CatalogActivationMode;
+        impact?: CatalogSourceImpact;
+        impactDigest?: string;
+        impactMode?: 'generation' | 'identityChange';
+        primaryImpact?: CatalogSourceImpact;
+        primaryImpactDigest?: string;
+        primaryConfigDigest?: string;
+        configDigest: string;
+        proposedConfigDigest?: string;
+        proposedSource?: CatalogSource;
+        sourceMutation?: Extract<OperationIntent, {
+            kind: 'catalogGeneration';
+        }>['sourceMutation'];
+        setPrimaryAfterActivation?: boolean;
     };
     portable?: PortableReview;
+    catalogStore?: CatalogStoreTaskEvidence;
 }
 export interface OperationReviewChange {
     kind: 'add' | 'change' | 'remove' | 'keep' | 'warning';
-    group?: 'requested' | 'dependencies' | 'portableTarget' | 'portableInputs' | 'portableWarnings' | 'preserved';
+    group?: 'requested' | 'dependencies' | 'projectIntent' | 'userIntent' | 'sharedCodexNative' | 'userActivation' | 'projectActivation' | 'awExtensions' | 'runtime' | 'portableTarget' | 'portableInputs' | 'portableWarnings' | 'configChanges' | 'configImpact' | 'preserved';
     pluginId?: string;
+    batchGroupId?: string;
+    sourceId?: string;
     relation?: 'requested' | 'direct' | 'transitive';
     title: string;
     description?: string;
@@ -119,6 +375,7 @@ export interface OperationReviewModel {
         kind: 'sourceMutation';
     }>['action'];
     pluginAction?: PluginWriteOperation;
+    taskGoal?: PluginWriteTaskGoal;
     originIssue?: IssueOrigin;
     title: string;
     description: string;
@@ -129,10 +386,62 @@ export interface OperationReviewModel {
         version?: string;
     };
     changes: OperationReviewChange[];
+    configImpact?: {
+        state: 'known' | 'unknown';
+        affectedTargetCount: number;
+    };
+    confirmationDetails?: string[];
     technicalDetails?: string[];
     equivalentCommand?: string;
     primaryLabel: string;
     destructive?: boolean;
+    requiresConfirmation: boolean;
+    sharedImpact: {
+        pluginIds: string[];
+        warning?: string;
+    };
+    catalogBinding?: {
+        sourceId: string;
+        catalogVersion: string;
+        generationDigestShort: string;
+    };
+    batch?: {
+        requestedPluginIds: string[];
+        groupCount: number;
+        executableGroupCount: number;
+    };
+    task?: {
+        goal: PluginWriteTaskGoal;
+        requestedTargetCount: number;
+        executableTargetCount: number;
+        blockedTargetCount: number;
+        causeCount: number;
+    };
+    rootSummary?: Array<{
+        pluginId: string;
+        version?: string;
+        targets: Array<{
+            platform: PlatformName | 'both';
+            scope: Scope;
+        }>;
+    }>;
+}
+export type ReviewPreparationStageId = 'refresh' | 'validate' | 'status' | 'catalog' | 'inventory' | 'dependencyPlan' | 'config' | 'portable' | 'evidence';
+export interface ReviewPreparationStage {
+    id: ReviewPreparationStageId;
+    label: string;
+    state: 'pending' | 'running' | 'completed' | 'failed';
+}
+export interface ReviewPreparationSnapshot {
+    id: string;
+    operationKind: OperationIntent['kind'];
+    subject: string;
+    state: 'running' | 'failed';
+    stages: ReviewPreparationStage[];
+    currentStage?: ReviewPreparationStageId;
+    code?: 'reviewPreparationFailed';
+    message?: string;
+    operationRecordId?: string;
 }
 export type OperationExecuteResult = {
     state: 'succeeded';
@@ -144,7 +453,11 @@ export type OperationExecuteResult = {
     }>['action'];
     pluginId?: string;
     originIssue?: IssueOrigin;
+    portableIntent?: PortableResultIntentMetadata;
     returnRoute?: TuiRoute;
+    operationRecordId?: string;
+    diagnosticIds?: string[];
+    effects?: OperationEffectFacts;
 } | {
     state: 'partial';
     operationId: string;
@@ -155,7 +468,11 @@ export type OperationExecuteResult = {
     }>['action'];
     pluginId?: string;
     originIssue?: IssueOrigin;
+    portableIntent?: PortableResultIntentMetadata;
     returnRoute?: TuiRoute;
+    operationRecordId?: string;
+    diagnosticIds?: string[];
+    effects?: OperationEffectFacts;
 } | {
     state: 'stale';
     operationId: string;
@@ -165,6 +482,10 @@ export type OperationExecuteResult = {
     }>['action'];
     review: OperationReviewModel;
     originIssue?: IssueOrigin;
+    portableIntent?: PortableResultIntentMetadata;
+    operationRecordId?: string;
+    diagnosticIds?: string[];
+    effects?: OperationEffectFacts;
 } | {
     state: 'blocked';
     operationId: string;
@@ -177,26 +498,89 @@ export type OperationExecuteResult = {
     pluginId?: string;
     returnRoute?: TuiRoute;
     originIssue?: IssueOrigin;
+    portableIntent?: PortableResultIntentMetadata;
     writeMayHaveCompleted?: boolean;
     verification?: 'issueStillPresent' | 'verificationFailed';
+    summary?: OperationResultSummary;
+    operationRecordId?: string;
+    diagnosticIds?: string[];
+    effects?: OperationEffectFacts;
 };
+export interface PortableResultIntentMetadata {
+    scope: Scope;
+    agentMode: 'automatic' | 'explicit';
+}
 export interface OperationResultSummary {
     code: 'operationSucceeded' | 'operationPartial' | 'operationFailed';
     message: string;
     pluginId?: string;
     action?: PluginWriteOperation;
+    catalogAction?: Extract<OperationIntent, {
+        kind: 'catalogGeneration';
+    }>['action'];
+    catalogGeneration?: Pick<CatalogGenerationSyncResult, 'activeChanged' | 'outcome'> & {
+        catalogVersion: string;
+    };
     elapsedMs?: number;
     messages?: string[];
+    configApplied?: boolean;
+    configApplySkippedReason?: 'invalidConfig';
+    configScope?: Scope;
+    configApplyRetryAvailable?: boolean;
+    configRetryApply?: boolean;
+    configGroups?: Array<{
+        scope: Scope;
+        configSaved: boolean;
+        applyRequested: boolean;
+        applyStatus: ConfigSaveBatchGroupResult['applyStatus'];
+        errorCode?: string;
+    }>;
+    resetDisposition?: 'absent' | 'deletedFile' | 'unlinkedSymlink' | 'quarantinedDirectory';
+    quarantineBasename?: string;
+    changes?: string[];
+    warnings?: string[];
+    recoveryActions?: string[];
+    planFingerprint?: string;
+    diagnosticIds?: string[];
+    effects?: OperationEffectFacts;
+    batch?: {
+        requestedPluginIds: string[];
+        failedRequestedPluginIds: string[];
+        rootResults: PluginWriteBatchRootResult[];
+        retryTargets?: PluginWriteBatchTarget[];
+        groupCount: number;
+    };
+    task?: {
+        goal: PluginWriteTaskGoal;
+        requestedTargets: PluginWriteTaskTarget[];
+        rootResults: PluginWriteTaskRootResult[];
+        retryTargets?: PluginWriteTaskTarget[];
+        blockedTargets: PluginWriteTaskBlockedTarget[];
+    };
     portable?: {
         selectedSkills: string[];
         agentMode: 'automatic' | 'explicit';
         requestedAgents: string[];
+        attemptedTargets?: Array<{
+            skill: string;
+            agent?: string;
+        }>;
         scope: Scope;
         materializationDigest: string;
+        skillsCliVersion: string;
+        verified: Array<{
+            name: string;
+            scope?: string;
+            agents: string[];
+        }>;
         missing: Array<{
             skill: string;
             agent?: string;
         }>;
+        unknown: Array<{
+            skill: string;
+            agent?: string;
+        }>;
         verificationUnknown: boolean;
         recovery?: string;
         failureCode?: string;
@@ -208,6 +592,34 @@ export interface OperationResultSummary {
         state: 'completed' | 'kept' | 'failed' | 'skipped';
         relation?: 'requested' | 'direct' | 'transitive';
         requiredBy?: string[];
+        errorCode?: string;
+        diagnosticIds?: string[];
+        effects?: OperationEffectFacts;
+    }>;
+}
+export interface PluginWriteTaskRootResult {
+    pluginId: string;
+    state: 'completed' | 'kept' | 'partial' | 'failed' | 'notStarted' | 'blocked';
+    causeKeys: string[];
+    targets: Array<{
+        pluginId?: string;
+        platform: PlatformName;
+        scope: Scope;
+        state: 'completed' | 'kept' | 'failed' | 'skipped';
+        relation?: 'requested' | 'direct' | 'transitive';
+        errorCode?: string;
+    }>;
+}
+export interface PluginWriteBatchRootResult {
+    pluginId: string;
+    state: 'completed' | 'kept' | 'partial' | 'failed' | 'notStarted';
+    targets: Array<{
+        pluginId: string;
+        platform: PlatformName;
+        scope: Scope;
+        state: 'completed' | 'kept' | 'failed' | 'skipped';
+        relation: 'requested';
+        errorCode?: string;
     }>;
 }
 export interface PluginOperationProgressLine {
@@ -219,11 +631,58 @@ export interface PluginOperationProgressLine {
     state: 'pending' | 'running' | 'completed' | 'kept' | 'failed' | 'skipped';
 }
 export interface TuiStatusLoadResult {
-    payload: StatusV4Payload;
-    pluginSummaries: StatusV4PluginSummary[];
+    projectRoot?: string;
+    projectIntent?: {
+        state: 'ready';
+        roots: Array<{
+            pluginId: string;
+            platforms: PlatformName[];
+        }>;
+    } | {
+        state: 'absent';
+    } | {
+        state: 'invalid' | 'unavailable';
+        code: string;
+        message: string;
+    };
+    /** Compatibility input for older injected status fixtures. Production uses projectIntent. */
+    projectIntentRoots?: Array<{
+        pluginId: string;
+        platforms: PlatformName[];
+    }>;
+    cliChannel?: 'latest' | 'beta';
+    payload: StatusV8Payload;
+    pluginSummaries: StatusV8PluginSummary[];
+    targetRevisions?: StatusTargetRevision[];
     sourceDetails?: SourceDetailViewModel[];
+    configuredSources?: CatalogSource[];
     dependencyOverviews?: PluginDependencyOverviewViewModel[];
+    contentOverviews?: Record<string, PluginContentOverview>;
     portablePluginIds?: string[];
+    configStoreInventory?: Array<{
+        pluginId: string;
+        sourceId: string;
+        pluginName: string;
+        scope: Scope;
+    }>;
+    catalogGenerations?: CatalogSourceGenerationViewModel[];
+    sessionGenerationKeys?: Record<string, string>;
+}
+export interface ProjectIntentReminderTarget extends PluginWriteBatchTarget {
+    reasonCodes: string[];
+}
+export interface ProjectIntentReminder {
+    projectRoot: string;
+    signature: string;
+    actionableTargets: ProjectIntentReminderTarget[];
+    blockedTargets: ProjectIntentReminderTarget[];
+    unconfirmedTargets: ProjectIntentReminderTarget[];
+}
+export declare function projectCurrentIntentReminder(status: TuiStatusLoadResult): ProjectIntentReminder | undefined;
+export interface InstallTargetOption {
+    platform: PlatformName;
+    compatible: boolean;
+    disabled?: string;
 }
 export interface SourceReferenceSummaryViewModel {
     blocked: boolean;
@@ -241,26 +700,32 @@ export interface SourceReferenceSummaryViewModel {
     }>;
 }
 export interface TuiControllerDependencies {
+    beginCatalogSession?: (options?: {
+        reuseValidatedGenerations?: boolean;
+    }) => void;
     loadStatus: (signal: AbortSignal) => Promise<TuiStatusLoadResult>;
-    checkSource: (sourceId: string, signal: AbortSignal) => Promise<{
-        sourceIdentity: string;
-        requestedRef: string;
-    }>;
+    loadPluginContent?: (pluginId: string, signal: AbortSignal) => Promise<PluginContentOverview>;
+    probeCatalogFreshness?: (sourceId: string, options: {
+        fullValidation: boolean;
+    }, signal: AbortSignal) => Promise<CatalogGenerationFreshnessResult>;
     inspectSourceRemoval?: (sourceId: string, signal: AbortSignal) => Promise<SourceReferenceSummaryViewModel>;
+    inspectCatalogStore?: (signal: AbortSignal) => Promise<CatalogStoreStatusResult>;
     captureEvidence: (intent: OperationIntent, signal?: AbortSignal) => Promise<OperationEvidence>;
+    recheckPortableInstall?: (receipt: PortableInstallReceipt, signal: AbortSignal) => Promise<PortableInstallReceipt>;
     validateIntent?: (intent: OperationIntent, signal: AbortSignal) => Promise<void>;
-    executeIntent: (intent: OperationIntent, expectedEvidence: OperationEvidence) => Promise<unknown>;
+    prepareReviewEvidence?: (intent: OperationIntent, signal: AbortSignal, onStage: (stage: ReviewPreparationStageId) => void | Promise<void>, reusableCandidate?: CatalogSessionReusableCandidate) => Promise<OperationEvidence>;
+    previewDependencyPlacement?: (intent: Extract<OperationIntent, {
+        kind: 'pluginWrite';
+    }>, signal: AbortSignal) => Promise<ReconcileOperationPlan | undefined>;
+    executeIntent: (intent: OperationIntent, expectedEvidence: OperationEvidence, signal?: AbortSignal) => Promise<unknown>;
     getConfigGroups?: (pluginId: string, layer: {
         scope: Scope;
-        projectLayer: ProjectConfigStoreLayer;
     }, signal: AbortSignal) => Promise<ConfigGroupViewModel[]>;
     getConfigPage?: (pluginId: string, layer: {
         scope: Scope | 'effective';
-        projectLayer: ProjectConfigStoreLayer;
     }, signal: AbortSignal) => Promise<ConfigPageViewModel>;
     getConfigResetAvailability?: (pluginId: string, layer: {
         scope: Scope;
-        projectLayer: ProjectConfigStoreLayer;
     }, signal: AbortSignal) => Promise<ConfigResetAvailability>;
     logError?: (error: unknown, code: string, context?: {
         privateConfigOperation: boolean;
@@ -272,19 +737,38 @@ export interface TuiControllerDependencies {
 }
 export interface ConfigResetAvailability {
     exists: boolean;
+    state: 'missing' | 'ready' | 'invalid';
+    targetKind?: 'absent' | 'regularFile' | 'symbolicLink' | 'directory' | 'special';
+    resettable?: boolean;
+    invalidCode?: ConfigInvalidStoreEvidence['code'];
     sourceIdentityPresent: boolean;
     sourceIdentity?: string;
     storeDigest?: string;
 }
+export interface ForceCleanupCandidate {
+    pluginId: string;
+    platform: PlatformName;
+    scope: Scope;
+    actionCount: number;
+}
 export interface TuiControllerSnapshot {
     phase: 'idle' | 'loading' | 'ready' | 'error' | 'disposed';
+    statusReadAtMs?: number;
+    cliChannel?: 'latest' | 'beta';
     router: TuiRouterSnapshot;
     viewModel?: TuiViewModel;
     sourceHealth: SourceHealthViewModel[];
+    catalogGenerations: CatalogSourceGenerationViewModel[];
+    catalogFreshness: CatalogSourceFreshnessViewModel[];
+    reloadRequiredSourceIds: string[];
     progress: RebuildProgressSnapshot;
     progressTargets: PluginOperationProgressLine[];
     activeReview?: OperationReviewModel;
+    reviewPreparation?: ReviewPreparationSnapshot;
     result?: OperationExecuteResult;
+    canResumeInstallDraft?: boolean;
+    operationHistorySummaries: OperationHistorySummary[];
+    portableResultSkills?: string[];
     loadError?: {
         code: string;
         message: string;
@@ -294,12 +778,42 @@ export interface TuiControllerSnapshot {
         requestedAgents: string[];
         scope: Scope;
     };
+    installPlacementDraft?: InstallPlacementDraftViewModel;
+    completionNotice?: {
+        pluginId: string;
+        title: string;
+        description: string;
+        operationRecordId?: string;
+    };
+    projectIntentReminder?: ProjectIntentReminder;
+    projectInventory?: ProjectInventoryViewModel;
+    projectInventoryRefresh: {
+        state: 'idle' | 'checking' | 'error';
+        checkedAtMs?: number;
+        errorCode?: string;
+    };
+    projectDeclarationAbsent?: boolean;
+    projectIntentIssue?: {
+        state: 'invalid' | 'unavailable';
+        code: string;
+        message: string;
+    };
 }
 export declare class TuiOperationBlockedError extends Error {
     readonly code: string;
-    constructor(code: string, message: string);
+    readonly diagnostics?: SafeOperationDiagnostic[];
+    constructor(code: string, message: string, diagnostics?: readonly SafeOperationDiagnostic[]);
+}
+export declare class TuiConfigInvalidStoreError extends Error {
+    readonly code = "invalidConfigStores";
+    readonly evidence: ConfigInvalidStoreEvidence[];
+    constructor(evidence: ConfigInvalidStoreEvidence[]);
 }
+export declare function pluginWriteBatchFailedRequestedTargets(execution: PluginWriteBatchExecutionResult): PluginWriteBatchTarget[];
+export declare function pluginWriteBatchFailedRequestedPluginIds(execution: PluginWriteBatchExecutionResult): string[];
+export declare function pluginWriteTaskFailedRequestedTargets(execution: PluginWriteTaskExecutionResult): PluginWriteTaskTarget[];
 export declare function operationEvidenceFingerprint(evidence: OperationEvidence): string;
+export declare function operationEvidenceMatches(expected: OperationEvidence, current: OperationEvidence): boolean;
 export declare function userIssueKey(issue: Pick<UserIssueViewModel, 'category' | 'pluginId' | 'dependencyPluginId' | 'dependencyPlatform' | 'dependencyScope' | 'dependencyProject' | 'sourceId' | 'sourceIdentity' | 'platform' | 'scope'>): string;
 export declare function extractPortableError(error: unknown): {
     code: PortableBlockerCode;
@@ -311,57 +825,146 @@ export declare class TuiController {
     constructor(dependencies: TuiControllerDependencies, progressFeed?: RebuildProgressFeed);
     get snapshot(): TuiControllerSnapshot;
     subscribe(listener: (snapshot: TuiControllerSnapshot) => void): () => void;
+    get hasActiveWrite(): boolean;
+    get retiring(): boolean;
+    get hasSessionDraft(): boolean;
+    get externalDrafts(): ExternalDraftState[];
+    attachOperationHistory(history: OperationHistoryStore, epoch: number): void;
+    listOperationHistory(): OperationHistorySummary[];
+    getOperationDiagnostic(recordId: string): OperationDiagnosticDetail | undefined;
+    previewOperationReport(recordId: string): OperationReportPreview | undefined;
+    saveOperationReport(recordId: string, filePath?: string): Promise<SaveOperationReportResult>;
+    /** @internal Test-only observability for bounded private diagnostic ownership. */
+    operationDiagnosticRetentionCountForTests(): number;
+    recordUiFailure(error: unknown, context: {
+        code: string;
+        stage: string;
+    }): string;
+    beginRetirement(): void;
+    waitForWrites(): Promise<void>;
+    cancelAndWaitForReads(): Promise<boolean>;
+    goHome(options?: {
+        discardDrafts?: boolean;
+    }): boolean;
     load(): Promise<void>;
-    refreshSource(sourceId: string): Promise<void>;
+    listProjectInventoryRoots(section?: 'declared' | 'extraInstalled'): ProjectInventoryRoot[];
+    getProjectInventoryRoot(pluginId: string): ProjectInventoryRoot | undefined;
+    refreshProjectInventory(): Promise<boolean>;
     push(route: TuiRoute, context?: TuiPageContext): void;
     hasPortableSkills(pluginId: string): boolean;
     preparePortableInstall(pluginId: string, navigation?: 'push' | 'replace'): Promise<PortableSkillSelectionViewModel>;
     refreshPortableInstallDraft(pluginId: string): Promise<PortableSkillSelectionViewModel>;
     togglePortableSkill(name: string): void;
     selectAllPortableSkills(): void;
+    clearPortableSkills(): void;
     setPortableAgentMode(mode: 'automatic' | 'explicit', requestedAgents?: string[]): void;
     setPortableScope(scope: Scope): void;
     buildPortableInstallReview(): Promise<OperationReviewModel>;
+    startPortableInstallReviewPreparation(): ReviewPreparationSnapshot;
+    recheckPortableResult(): Promise<PortableInstallReceipt>;
+    startPortableRetryReviewPreparation(): ReviewPreparationSnapshot;
     discardPortableDraft(): void;
     replace(route: TuiRoute, context?: TuiPageContext): void;
+    beginConfigFlow(pluginId: string): void;
+    beginSavedConfigRecovery(pluginId: string): void;
+    beginConfigSourceRecovery(sourceId: string): void;
+    getForceCleanupCandidate(pluginId: string, platform: PlatformName, scope: Scope): Promise<ForceCleanupCandidate | undefined>;
+    startForceCleanupReview(candidate: ForceCleanupCandidate): ReviewPreparationSnapshot;
+    configOrigin(pluginId: string): TuiRoute | undefined;
     updatePageContext(context: Partial<TuiPageContext>): void;
+    returnToConfigOverview(flowId: string | undefined, overviewFrameId: string | undefined, pluginId: string, context?: TuiPageContext): boolean;
+    configOverviewFrameId(flowId: string | undefined, pluginId: string): string | undefined;
     back(): void;
     discardSourceDraft(owner: string, returnRoute: Extract<TuiRoute, {
         name: 'sourceList' | 'sourceDetail';
     }>): void;
     leaveResult(target?: TuiRoute): void;
+    resumeResultDraft(): void;
     resetPortableFlowToPreview(pluginId: string, target?: TuiRoute, preserveDraft?: boolean): void;
+    beginInstallFlow(pluginId: string, rootScope: Scope): void;
+    setInstallRootScope(rootScope: Scope): void;
+    setInstallPlatforms(platforms: PlatformName[]): void;
+    setInstallRootTargets(targets: PluginWriteBatchTarget[]): void;
+    prepareInstallDependencyPlacement(): Promise<boolean>;
+    setDependencyScope(pluginId: string, platform: PlatformName, scope: Scope): Promise<void>;
+    resetDependencyScopes(): Promise<void>;
+    installPlacementIntent(): Extract<OperationIntent, {
+        kind: 'pluginWrite' | 'pluginWriteBatch';
+    }>;
     listPlugins(options: {
         mode: 'browse' | 'installed';
         sourceId?: string;
         query?: string;
+        installFilter?: PluginInstallFilter;
     }): PluginListItemViewModel[];
     getPluginOverview(pluginId: string): PluginListItemViewModel | undefined;
+    getPluginDetailSubject(pluginId: string): PluginDetailSubject | undefined;
+    getPluginContentOverview(pluginId: string): PluginContentOverview | undefined;
+    getPluginContentState(pluginId: string): 'idle' | 'loading' | 'ready';
+    loadPluginContent(pluginId: string): Promise<void>;
+    getPluginSourceIdentity(pluginId: string): string | undefined;
+    listCurrentProjectIntentRoots(): string[];
+    listPluginWriteBatchTargets(action: Exclude<BatchPluginWriteAction, 'install'>, pluginIds: readonly string[]): PluginWriteBatchTarget[];
+    listPluginInstallBatchTargets(pluginIds: readonly string[], platform: PlatformName | 'both', scope: Scope): PluginInstallBatchTarget[];
+    pluginHasInstallableTarget(pluginId: string): boolean;
     getPluginDependencyOverview(pluginId: string): PluginDependencyOverviewViewModel | undefined;
+    listPluginDependencyOverviews(): PluginDependencyOverviewViewModel[];
     getBlockingDependents(pluginId: string, platform: PlatformName, scope: Scope): PluginDependencyOverviewViewModel['dependents'];
     getPlatformPlacement(pluginId: string, platform: PlatformName): PluginListItemViewModel['installedPlacements'][number] | undefined;
-    getTargetState(pluginId: string, platform: PlatformName, scope: Scope): StatusV4Payload['targets'][number]['state'] | undefined;
+    listInstallTargets(pluginId: string, scope: Scope): InstallTargetOption[];
+    getTargetState(pluginId: string, platform: PlatformName, scope: Scope): StatusV8Payload['targets'][number]['state'] | undefined;
     listSources(): TuiViewModel['sourceTabs'];
     getSourceOverview(sourceId: string): {
         source?: TuiViewModel['sourceTabs'][number];
         detail?: SourceDetailViewModel;
         health?: SourceHealthViewModel;
     };
+    getConfiguredSource(sourceId: string): CatalogSource | undefined;
+    getCatalogGeneration(sourceId: string): CatalogSourceGenerationViewModel | undefined;
+    getCatalogFreshness(sourceId: string): CatalogSourceFreshnessViewModel | undefined;
+    recheckCatalogSource(sourceId: string): Promise<void>;
+    recheckAllCatalogSources(): Promise<void>;
+    fullValidateCatalogSource(sourceId: string): Promise<void>;
+    setExternalDraftState(states?: ExternalDraftState[]): void;
+    beginPluginWriteBatch(): void;
+    startPluginWriteBatchReview(intent: PluginWriteBatchIntent): ReviewPreparationSnapshot;
+    startPluginWriteTaskReview(intent: PluginWriteTaskIntent, returnRoute?: TuiRoute): ReviewPreparationSnapshot;
+    beginNestedPluginWriteTask(route: Extract<TuiRoute, {
+        name: 'pluginWriteTask';
+    }>): void;
+    pluginWriteTaskReturnRoute(route: Extract<TuiRoute, {
+        name: 'pluginWriteTask';
+    }>): TuiRoute;
+    returnToPluginWriteTaskBatchSelection(flowId: string): boolean;
+    retryFailedPluginWriteBatch(): ReviewPreparationSnapshot | undefined;
+    retryFailedPluginWriteTask(): ReviewPreparationSnapshot | undefined;
+    catalogActivationBlockReason(): CatalogActivationBlockReason | undefined;
+    catalogSourceRecoveryBlockReason(intent?: Extract<OperationIntent, {
+        kind: 'catalogGeneration';
+    }>): CatalogActivationBlockReason | undefined;
+    getSessionCatalogVersion(sourceId: string): string | undefined;
+    reloadCatalog(options: {
+        sourceId: string;
+    }): Promise<boolean>;
     inspectSourceRemoval(sourceId: string): Promise<SourceReferenceSummaryViewModel>;
+    inspectCatalogStore(): Promise<CatalogStoreStatusResult>;
     getConfigGroups(pluginId: string, layer: {
         scope: Scope;
-        projectLayer: ProjectConfigStoreLayer;
     }): Promise<ConfigGroupViewModel[]>;
     getConfigPage(pluginId: string, layer: {
         scope: Scope | 'effective';
-        projectLayer: ProjectConfigStoreLayer;
     }, signal?: AbortSignal): Promise<ConfigPageViewModel>;
+    previewConfigSaveImpact(intent: Extract<OperationIntent, {
+        kind: 'configSave';
+    }>, signal?: AbortSignal): Promise<NonNullable<OperationEvidence['config']>>;
     getConfigResetAvailability(pluginId: string, layer: {
         scope: Scope;
-        projectLayer: ProjectConfigStoreLayer;
     }): Promise<ConfigResetAvailability>;
     listUserIssues(): UserIssueViewModel[];
+    listPluginWriteTaskCandidates(goal: PluginWriteTaskGoal): PluginWriteTaskCandidate[];
     buildOperationReview(intent: OperationIntent, returnRoute?: TuiRoute): Promise<OperationReviewModel>;
+    startReviewPreparation(intent: OperationIntent, returnRoute?: TuiRoute): ReviewPreparationSnapshot;
+    retryReviewPreparation(): ReviewPreparationSnapshot | undefined;
     executeOperation(reviewToken: string): Promise<OperationExecuteResult>;
     dispose(): void;
 }