@xopcai/xopc 0.0.197 → 0.0.199

package/dist/src/proactive/execution/types.d.ts

@@ -20,6 +20,15 @@ export interface InsightCandidate {
             consequence: string;
         }>;
     };
+    proposedAction?: {
+        id: 'create_project_task';
+        risk: 'low';
+        rationale: string;
+        input: {
+            title: string;
+            objective: string;
+        };
+    };
     urgency: 'low' | 'medium' | 'high' | 'critical';
     confidence: number;
     evidenceIds: string[];
@@ -30,6 +39,11 @@ export interface ProactiveInsight extends InsightCandidate {
     subscriptionId: string;
     scenarioKey: string;
     valueScore: number;
+    disposition?: 'record_silently' | 'show_in_work' | 'request_approval' | 'auto_execute';
+    dispositionReason?: string;
+    actionStatus?: 'not_authorized' | 'approval_required' | 'pending' | 'executing' | 'completed' | 'rejected' | 'failed';
+    actionResult?: Record<string, unknown>;
+    actionError?: string;
     createdAt: string;
 }
 export interface ProactiveAgentExecutor {

package/dist/src/proactive/inbox/repository.js

@@ -1,4 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { decideProactiveDisposition, nextQuietHoursEnd, proactiveDispositionReason } from "../../tasks/project-monitoring-service.js";
 import { randomUUID } from "node:crypto";
 //#region src/proactive/inbox/repository.ts
 const s = (row, key) => String(row[key]);
@@ -20,6 +21,12 @@ function itemFromRow(row) {
 			recommendation: s(row, "recommendation"),
 			workDone: s(row, "work_done"),
 			...row.decision_json ? { decision: JSON.parse(s(row, "decision_json")) } : {},
+			...row.proposed_action_json ? { proposedAction: JSON.parse(s(row, "proposed_action_json")) } : {},
+			disposition: s(row, "disposition"),
+			dispositionReason: s(row, "disposition_reason"),
+			...row.action_status ? { actionStatus: s(row, "action_status") } : {},
+			...row.action_result_json ? { actionResult: JSON.parse(s(row, "action_result_json")) } : {},
+			...row.action_error ? { actionError: s(row, "action_error") } : {},
 			urgency: s(row, "urgency"),
 			confidence: Number(row.confidence),
 			valueScore: Number(row.value_score),
@@ -28,27 +35,70 @@ function itemFromRow(row) {
 	};
 }
 const SELECT_ITEM = `SELECT i.*, x.subscription_id, x.scenario_key, x.title, x.summary, x.why_now, x.impact, x.recommendation,
-  x.work_done, x.decision_json, x.urgency, x.confidence, x.value_score, x.evidence_ids_json FROM proactive_inbox_items i
+  x.work_done, x.decision_json, x.proposed_action_json, x.disposition, x.disposition_reason,
+  x.action_status, x.action_result_json, x.action_error, x.urgency, x.confidence, x.value_score, x.evidence_ids_json FROM proactive_inbox_items i
   JOIN proactive_insights x ON x.insight_id = i.insight_id`;
 function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
-		const missing = db.prepare(`SELECT x.insight_id FROM proactive_insights x
+		const missing = db.prepare(`SELECT x.insight_id, x.confidence, x.value_score, x.decision_json,
+      x.proposed_action_json, b.aggregation_key, p.project_id, p.mode, p.quiet_hours_json,
+      p.allowed_actions_json, p.confidence_threshold FROM proactive_insights x
       JOIN proactive_runs r ON r.run_id = x.run_id
       JOIN proactive_signal_batches b ON b.batch_id = r.batch_id
       LEFT JOIN project_monitoring_policies p
         ON b.aggregation_key = 'project:' || p.project_id
-      WHERE x.insight_id NOT IN (SELECT insight_id FROM proactive_inbox_items)
-        AND (p.project_id IS NULL OR (p.mode != 'observe' AND x.confidence >= p.confidence_threshold))
-      ORDER BY x.created_at`).all();
+      WHERE x.disposition IS NULL ORDER BY x.created_at`).all();
+		let projected = 0;
 		for (const row of missing) {
-			const id = randomUUID();
+			const aggregationKey = String(row.aggregation_key);
+			const projectId = aggregationKey.startsWith("project:") ? aggregationKey.slice(8) : void 0;
+			const policy = projectId ? row.project_id ? {
+				projectId,
+				mode: String(row.mode),
+				...row.quiet_hours_json ? { quietHours: JSON.parse(String(row.quiet_hours_json)) } : {},
+				allowedActions: JSON.parse(String(row.allowed_actions_json)),
+				confidenceThreshold: Number(row.confidence_threshold),
+				scenarios: [],
+				configured: true
+			} : {
+				projectId,
+				mode: "observe",
+				allowedActions: [],
+				confidenceThreshold: .75,
+				scenarios: [],
+				configured: false
+			} : {
+				projectId: "",
+				mode: "ask_before_action",
+				allowedActions: [],
+				confidenceThreshold: 0,
+				scenarios: [],
+				configured: false
+			};
+			const action = row.proposed_action_json ? JSON.parse(String(row.proposed_action_json)) : void 0;
+			const dispositionInput = {
+				confidence: Number(row.confidence),
+				valueScore: Number(row.value_score),
+				risk: action?.risk ?? "low",
+				...action ? { actionId: action.id } : {},
+				requiresApproval: !action && Boolean(row.decision_json)
+			};
+			const disposition = action && !projectId ? "show_in_work" : decideProactiveDisposition(policy, dispositionInput);
+			const reason = action && !projectId ? "Proposed project action cannot run outside a project scope" : proactiveDispositionReason(policy, dispositionInput, disposition);
+			const actionStatus = action ? disposition === "auto_execute" ? "pending" : disposition === "request_approval" ? "approval_required" : disposition === "show_in_work" ? "not_authorized" : null : null;
 			const nowIso = now.toISOString();
+			db.prepare(`UPDATE proactive_insights SET disposition = ?, disposition_reason = ?, action_status = ?,
+        disposition_at = ?, action_updated_at = ? WHERE insight_id = ? AND disposition IS NULL`).run(disposition, reason, actionStatus, nowIso, actionStatus ? nowIso : null, String(row.insight_id));
+			if (disposition === "record_silently") continue;
+			const id = randomUUID();
 			db.prepare(`INSERT INTO proactive_inbox_items (inbox_item_id, insight_id, status, created_at, updated_at)
-        VALUES (?, ?, 'unread', ?, ?)`).run(id, row.insight_id, nowIso, nowIso);
+        VALUES (?, ?, 'unread', ?, ?)`).run(id, String(row.insight_id), nowIso, nowIso);
+			const nextAttemptAt = nextQuietHoursEnd(policy.quietHours, now)?.toISOString() ?? nowIso;
 			db.prepare(`INSERT INTO proactive_delivery_outbox (delivery_id, inbox_item_id, status, attempt, next_attempt_at, created_at, updated_at)
-        VALUES (?, ?, 'pending', 0, ?, ?, ?)`).run(randomUUID(), id, nowIso, nowIso, nowIso);
+        VALUES (?, ?, 'pending', 0, ?, ?, ?)`).run(randomUUID(), id, nextAttemptAt, nowIso, nowIso);
+			projected += 1;
 		}
-		return missing.length;
+		return projected;
 	});
 }
 function wakeSnoozedItems(now = /* @__PURE__ */ new Date()) {

package/dist/src/proactive/inbox/service.d.ts

@@ -1,11 +1,11 @@
-import { listInbox, projectInsightsToInbox, recordDecision, recordFeedback, wakeSnoozedItems } from './repository.js';
+import { listInbox, projectInsightsToInbox, recordFeedback, wakeSnoozedItems } from './repository.js';
 import type { InboxStatus } from './types.js';
 export declare class ProactiveInboxService {
     list: typeof listInbox;
     project: typeof projectInsightsToInbox;
     wakeSnoozed: typeof wakeSnoozedItems;
-    decide: typeof recordDecision;
     feedback: typeof recordFeedback;
+    decide(id: string, choice: string, note?: string): import("./types.js").InboxItem;
     instruct(id: string, instruction: string): {
         revisionId: string;
     };

package/dist/src/proactive/inbox/service.js

@@ -1,12 +1,17 @@
 import { publishInstructionFeedback } from "../scenarios/repository.js";
-import { getInboxSubscriptionId, listInbox, projectInsightsToInbox, recordDecision, recordFeedback, transitionInboxItem, wakeSnoozedItems } from "./repository.js";
+import { resolveProactiveActionDecision } from "../actions/service.js";
+import { getInboxItem, getInboxSubscriptionId, listInbox, projectInsightsToInbox, recordDecision, recordFeedback, transitionInboxItem, wakeSnoozedItems } from "./repository.js";
 //#region src/proactive/inbox/service.ts
 var ProactiveInboxService = class {
 	list = listInbox;
 	project = projectInsightsToInbox;
 	wakeSnoozed = wakeSnoozedItems;
-	decide = recordDecision;
 	feedback = recordFeedback;
+	decide(id, choice, note = "") {
+		const item = recordDecision(id, choice, note);
+		resolveProactiveActionDecision(id, choice);
+		return getInboxItem(id) ?? item;
+	}
 	instruct(id, instruction) {
 		return { revisionId: publishInstructionFeedback({
 			subscriptionId: getInboxSubscriptionId(id),

package/dist/src/proactive/inbox/types.d.ts

@@ -23,6 +23,20 @@ export interface InboxItem {
                 consequence: string;
             }>;
         };
+        proposedAction?: {
+            id: 'create_project_task';
+            risk: 'low';
+            rationale: string;
+            input: {
+                title: string;
+                objective: string;
+            };
+        };
+        disposition: 'show_in_work' | 'request_approval' | 'auto_execute';
+        dispositionReason: string;
+        actionStatus?: 'not_authorized' | 'approval_required' | 'pending' | 'executing' | 'completed' | 'rejected' | 'failed';
+        actionResult?: Record<string, unknown>;
+        actionError?: string;
         urgency: 'low' | 'medium' | 'high' | 'critical';
         confidence: number;
         valueScore: number;

package/dist/src/proactive/inbox/worker.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { executePendingProactiveActions } from "../actions/service.js";
 import { claimDelivery, finishDelivery, projectInsightsToInbox, recoverExpiredDeliveries, wakeSnoozedItems } from "./repository.js";
 //#region src/proactive/inbox/worker.ts
 init_logger();
@@ -28,6 +29,7 @@ var ProactiveInboxWorker = class {
 		this.running = true;
 		try {
 			projectInsightsToInbox();
+			executePendingProactiveActions();
 			wakeSnoozedItems();
 			recoverExpiredDeliveries();
 			const claim = claimDelivery();

package/dist/src/proactive/scenarios/prompt-composer.js

@@ -5,8 +5,8 @@ Use only supplied evidence identifiers. Separate observations from inferences.
 Do not invent dates, owners, dependencies, impact, or actions.
 Return only the protected output schema.`;
 const OUTPUT_CONTRACT = `Return JSON only with these fields:
-{"title":"...","summary":"...","whyNow":"...","impact":"...","workDone":"What you investigated or ruled out","recommendation":"...","decision":{"question":"The exact user decision","options":[{"id":"stable-id","label":"short choice","consequence":"likely consequence"}]},"urgency":"low|medium|high|critical","confidence":0.0,"evidenceIds":["event-id"]}
-Use decision only when the user must choose; otherwise set decision to null. Provide 2-3 mutually exclusive options. If evidence does not support a timely and actionable insight, return the same shape with urgency "low" and confidence below 0.65. Never add unknown fields.`;
+{"title":"...","summary":"...","whyNow":"...","impact":"...","workDone":"What you investigated or ruled out","recommendation":"...","decision":{"question":"The exact user decision","options":[{"id":"stable-id","label":"short choice","consequence":"likely consequence"}]},"proposedAction":{"id":"create_project_task","risk":"low","rationale":"why this is safe and useful","input":{"title":"...","objective":"..."}},"urgency":"low|medium|high|critical","confidence":0.0,"evidenceIds":["event-id"]}
+Use proposedAction only when the evidence clearly supports creating a follow-up task in the current project; otherwise set it to null. A proposed action must include exactly two decision options in this order: approve, reject. Use decision without proposedAction only when the user must choose; otherwise set decision to null. Provide 2-3 mutually exclusive options. If evidence does not support a timely and actionable insight, return the same shape with urgency "low" and confidence below 0.65. Never add unknown fields.`;
 function composeScenarioPrompt(input) {
 	const parts = {
 		platformSafety: PLATFORM_SAFETY,

package/dist/src/storage/sqlite/migrations/118_task_board_rank.sql

@@ -0,0 +1,6 @@
+ALTER TABLE tasks ADD COLUMN board_rank INTEGER NOT NULL DEFAULT 0;
+
+UPDATE tasks SET board_rank = created_at;
+
+CREATE INDEX idx_tasks_project_phase_rank
+  ON tasks(project_id, phase, board_rank, created_at);

package/dist/src/storage/sqlite/migrations/119_proactive_disposition.sql

@@ -0,0 +1,13 @@
+ALTER TABLE proactive_insights ADD COLUMN proposed_action_json TEXT;
+ALTER TABLE proactive_insights ADD COLUMN disposition TEXT
+  CHECK (disposition IN ('record_silently', 'show_in_work', 'request_approval', 'auto_execute'));
+ALTER TABLE proactive_insights ADD COLUMN disposition_reason TEXT;
+ALTER TABLE proactive_insights ADD COLUMN action_status TEXT
+  CHECK (action_status IN ('not_authorized', 'approval_required', 'pending', 'executing', 'completed', 'rejected', 'failed'));
+ALTER TABLE proactive_insights ADD COLUMN action_result_json TEXT;
+ALTER TABLE proactive_insights ADD COLUMN action_error TEXT;
+ALTER TABLE proactive_insights ADD COLUMN disposition_at TEXT;
+ALTER TABLE proactive_insights ADD COLUMN action_updated_at TEXT;
+
+CREATE INDEX idx_proactive_insights_action_status
+  ON proactive_insights(action_status, created_at);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 117;
+export declare const XOPC_DB_SCHEMA_VERSION = 119;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 117;
+const XOPC_DB_SCHEMA_VERSION = 119;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function backupBeforeTaskCutover(db, databasePath) {
 	db.exec("PRAGMA wal_checkpoint(FULL)");
@@ -57,7 +57,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 117;
+	const targetVersion = options.targetVersion ?? 119;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -94,7 +94,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 117;
+	const appVersion = options.targetVersion ?? 119;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

package/dist/src/storage/sqlite/migrations/runner.ts

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 117;
+export const XOPC_DB_SCHEMA_VERSION = 119;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/schema.js

@@ -32,7 +32,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 11;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 117,
+		targetVersion: 119,
 		databasePath: options.databasePath
 	});
 }

package/dist/src/tasks/home-query-service.d.ts

@@ -105,6 +105,11 @@ export declare function buildHomeBriefing(input: {
             recommendation: string;
             confidence: number;
             valueScore?: number;
+            disposition?: "show_in_work" | "request_approval" | "auto_execute";
+            dispositionReason?: string;
+            actionStatus?: "failed" | "completed" | "rejected" | "pending" | "approval_required" | "not_authorized" | "executing";
+            proposedActionTitle?: string;
+            actionError?: string;
             decision?: {
                 question: string;
                 options: {

package/dist/src/tasks/home-query-service.js

@@ -451,7 +451,7 @@ var HomeQueryService = class {
 				kind: "agent_judgment",
 				title: item.insight.title,
 				detail: item.insight.summary,
-				reason: "decision_needed",
+				reason: item.insight.disposition === "request_approval" ? "approval_required" : "decision_needed",
 				urgency: item.insight.urgency === "critical" || item.insight.urgency === "high" ? "now" : "soon",
 				href: `/?judgment=${encodeURIComponent(item.id)}`,
 				updatedAt: Date.parse(item.updatedAt),
@@ -463,7 +463,12 @@ var HomeQueryService = class {
 					recommendation: item.insight.recommendation,
 					confidence: item.insight.confidence,
 					valueScore: item.insight.valueScore,
-					...item.insight.decision ? { decision: item.insight.decision } : {}
+					disposition: item.insight.disposition,
+					dispositionReason: item.insight.dispositionReason,
+					...item.insight.actionStatus ? { actionStatus: item.insight.actionStatus } : {},
+					...item.insight.proposedAction ? { proposedActionTitle: item.insight.proposedAction.input.title } : {},
+					...item.insight.actionError ? { actionError: item.insight.actionError } : {},
+					...item.insight.decision && (!item.insight.proposedAction || item.insight.actionStatus === "approval_required") ? { decision: item.insight.decision } : {}
 				}
 			})),
 			...activeTasks.map((task) => decisionFromTask(this.#projector.project(task), task.projectId ? projectsById.get(task.projectId)?.name : void 0)).filter((item) => Boolean(item)),

package/dist/src/tasks/index.d.ts

@@ -11,6 +11,7 @@ export * from './project-operating-view-service.js';
 export * from './project-monitoring-service.js';
 export * from './task-value-metrics-service.js';
 export * from './task-application-service.js';
+export * from './task-change-events.js';
 export * from './task-context-repository.js';
 export * from './task-dependency-service.js';
 export * from './task-read-model-projector.js';

package/dist/src/tasks/index.js

@@ -5,6 +5,7 @@ import { resolveExecutionContext } from "./execution-context.js";
 import { AttentionGovernor } from "./attention-governor.js";
 import { HomeQueryService, buildHomeBriefing, buildHomeFocusItems, decisionFromTask } from "./home-query-service.js";
 import { TaskContextRepository } from "./task-context-repository.js";
+import { enqueueTaskChanged, enqueueTaskChangedEvent } from "./task-change-events.js";
 import { TaskDependencyError, TaskDependencyService } from "./task-dependency-service.js";
 import { TaskApplicationService } from "./task-application-service.js";
 import { TaskWorkflowCoordinator } from "./task-workflow-coordinator.js";
@@ -12,10 +13,10 @@ import { defineTaskContract } from "./task-contract-definition.js";
 import { ModelTaskContractPlanner, parseTaskContractResponse } from "./task-contract-planner.js";
 import { assembleTaskContext, buildTaskExecutionDirective, getTaskContextManifest, getTaskExecutionBrief } from "./task-context-assembler.js";
 import { TaskRunCoordinator } from "./task-run-coordinator.js";
-import { ProjectMonitoringService, decideProactiveDisposition } from "./project-monitoring-service.js";
-import { ProjectOperatingViewService, projectTaskLane, summarizeProjectOperatingView } from "./project-operating-view-service.js";
+import { ProjectMonitoringService, decideProactiveDisposition, isInQuietHours, nextQuietHoursEnd, proactiveDispositionReason } from "./project-monitoring-service.js";
+import { ProjectOperatingViewService, summarizeProjectOperatingView } from "./project-operating-view-service.js";
 import { TaskValueMetricsService } from "./task-value-metrics-service.js";
 import { TaskOutboxDispatcher } from "./task-outbox-dispatcher.js";
 import { TaskRunDispatcher } from "./task-run-dispatcher.js";
 import { TaskSignalService } from "./task-signal-service.js";
-export { AttentionGovernor, HomeQueryService, ModelTaskContractPlanner, ProjectMonitoringService, ProjectOperatingViewService, TaskApplicationService, TaskContextRepository, TaskDependencyError, TaskDependencyService, TaskOutboxDispatcher, TaskReadModelProjector, TaskRepository, TaskRunCoordinator, TaskRunDispatcher, TaskRunRepository, TaskSignalService, TaskValueMetricsService, TaskWorkflowCoordinator, assembleTaskContext, buildHomeBriefing, buildHomeFocusItems, buildTaskExecutionDirective, decideProactiveDisposition, decisionFromTask, defineTaskContract, getTaskContextManifest, getTaskExecutionBrief, parseTaskContractResponse, projectTaskLane, resolveExecutionContext, summarizeProjectOperatingView };
+export { AttentionGovernor, HomeQueryService, ModelTaskContractPlanner, ProjectMonitoringService, ProjectOperatingViewService, TaskApplicationService, TaskContextRepository, TaskDependencyError, TaskDependencyService, TaskOutboxDispatcher, TaskReadModelProjector, TaskRepository, TaskRunCoordinator, TaskRunDispatcher, TaskRunRepository, TaskSignalService, TaskValueMetricsService, TaskWorkflowCoordinator, assembleTaskContext, buildHomeBriefing, buildHomeFocusItems, buildTaskExecutionDirective, decideProactiveDisposition, decisionFromTask, defineTaskContract, enqueueTaskChanged, enqueueTaskChangedEvent, getTaskContextManifest, getTaskExecutionBrief, isInQuietHours, nextQuietHoursEnd, parseTaskContractResponse, proactiveDispositionReason, resolveExecutionContext, summarizeProjectOperatingView };

package/dist/src/tasks/project-monitoring-service.d.ts

@@ -7,6 +7,15 @@ export declare function decideProactiveDisposition(policy: ProjectMonitoringPoli
     actionId?: string;
     requiresApproval?: boolean;
 }): ProactiveDisposition;
+export declare function proactiveDispositionReason(policy: ProjectMonitoringPolicy, input: {
+    confidence: number;
+    valueScore: number;
+    risk: 'low' | 'medium' | 'high';
+    actionId?: string;
+    requiresApproval?: boolean;
+}, disposition: ProactiveDisposition): string;
+export declare function isInQuietHours(quietHours: QuietHours | undefined, now?: Date): boolean;
+export declare function nextQuietHoursEnd(quietHours: QuietHours | undefined, now?: Date): Date | undefined;
 export declare class ProjectMonitoringService {
     #private;
     get(projectId: string): ProjectMonitoringPolicy;

package/dist/src/tasks/project-monitoring-service.js

@@ -2,6 +2,7 @@ import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/
 import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
 //#region src/tasks/project-monitoring-service.ts
 const DEFAULT_SCENARIOS = ["project_delivery_risk", "blocked_work"];
+const SUPPORTED_ACTIONS = new Set(["create_project_task"]);
 function validHour(value) {
 	return Number.isInteger(value) && value >= 0 && value <= 23;
 }
@@ -19,10 +20,45 @@ function rowToPolicy(row, scenarios) {
 }
 function decideProactiveDisposition(policy, input) {
 	if (policy.mode === "observe" || input.confidence < policy.confidenceThreshold || input.valueScore < .5) return "record_silently";
-	if (input.requiresApproval || input.risk !== "low") return "request_approval";
-	if (policy.mode === "auto_low_risk" && input.actionId && policy.allowedActions.includes(input.actionId)) return "auto_execute";
+	if (input.actionId) {
+		if (input.requiresApproval || input.risk !== "low" || policy.mode === "ask_before_action") return "request_approval";
+		if (policy.mode === "auto_low_risk" && policy.allowedActions.includes(input.actionId)) return "auto_execute";
+		return "show_in_work";
+	}
+	if (input.requiresApproval) return "request_approval";
 	return "show_in_work";
 }
+function proactiveDispositionReason(policy, input, disposition) {
+	if (policy.mode === "observe") return "Project monitoring is observe-only";
+	if (input.confidence < policy.confidenceThreshold) return `Confidence ${input.confidence} is below threshold ${policy.confidenceThreshold}`;
+	if (input.valueScore < .5) return `Value score ${input.valueScore} is below 0.5`;
+	if (disposition === "request_approval") return input.risk === "low" ? "Project policy requires approval before acting" : `${input.risk} risk requires approval`;
+	if (disposition === "auto_execute") return `Low-risk action ${input.actionId} is explicitly allowed`;
+	if (input.actionId && !policy.allowedActions.includes(input.actionId)) return `Action ${input.actionId} is not in the project allowlist`;
+	return "Insight passed the project confidence and value gates";
+}
+function hourInTimezone(now, timezone) {
+	const hour = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		hour: "2-digit",
+		hourCycle: "h23"
+	}).formatToParts(now).find((part) => part.type === "hour")?.value;
+	return Number(hour);
+}
+function isInQuietHours(quietHours, now = /* @__PURE__ */ new Date()) {
+	if (!quietHours || quietHours.startHour === quietHours.endHour) return false;
+	const hour = hourInTimezone(now, quietHours.timezone);
+	return quietHours.startHour < quietHours.endHour ? hour >= quietHours.startHour && hour < quietHours.endHour : hour >= quietHours.startHour || hour < quietHours.endHour;
+}
+function nextQuietHoursEnd(quietHours, now = /* @__PURE__ */ new Date()) {
+	if (!isInQuietHours(quietHours, now)) return void 0;
+	const minute = new Date(now);
+	minute.setUTCSeconds(0, 0);
+	for (let offset = 1; offset <= 2880; offset += 1) {
+		const candidate = new Date(minute.getTime() + offset * 6e4);
+		if (!isInQuietHours(quietHours, candidate)) return candidate;
+	}
+}
 var ProjectMonitoringService = class {
 	#scenarios = new ProactiveScenarioService();
 	get(projectId) {
@@ -40,9 +76,11 @@ var ProjectMonitoringService = class {
 	configure(input) {
 		if (!getSqliteDatabase().prepare("SELECT 1 FROM projects WHERE project_id = ?").get(input.projectId)) throw new Error("Project not found");
 		if (input.quietHours && (!validHour(input.quietHours.startHour) || !validHour(input.quietHours.endHour) || !input.quietHours.timezone.trim())) throw new Error("Quiet hours need a timezone and integer hours from 0 through 23");
+		if (input.quietHours) hourInTimezone(/* @__PURE__ */ new Date(), input.quietHours.timezone);
 		const threshold = input.confidenceThreshold ?? .75;
 		if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) throw new Error("confidenceThreshold must be between 0 and 1");
 		const allowedActions = [...new Set(input.allowedActions ?? [])].map((action) => action.trim()).filter(Boolean);
+		if (allowedActions.some((action) => !SUPPORTED_ACTIONS.has(action))) throw new Error("Unknown proactive action");
 		const scenarios = [...new Set(input.scenarios ?? DEFAULT_SCENARIOS)];
 		const availableScenarios = new Set(this.#scenarios.list().map((scenario) => scenario.key));
 		if (scenarios.some((scenario) => !availableScenarios.has(scenario))) throw new Error("Unknown proactive scenario");
@@ -73,4 +111,4 @@ var ProjectMonitoringService = class {
 	}
 };
 //#endregion
-export { ProjectMonitoringService, decideProactiveDisposition };
+export { ProjectMonitoringService, decideProactiveDisposition, isInQuietHours, nextQuietHoursEnd, proactiveDispositionReason };

package/dist/src/tasks/project-operating-view-service.d.ts

@@ -1,6 +1,5 @@
-import type { ProjectOperatingSummary, ProjectOperatingView, ProjectTaskCard } from '@xopcai/gateway-contract';
+import type { ProjectOperatingSummary, ProjectOperatingView } from '@xopcai/gateway-contract';
 import type { ProjectService } from '../projects/index.js';
-export declare function projectTaskLane(card: Pick<ProjectTaskCard, 'phase' | 'operationalState' | 'attention'>): ProjectTaskCard['lane'];
 export declare function summarizeProjectOperatingView(view: ProjectOperatingView): ProjectOperatingSummary;
 export declare class ProjectOperatingViewService {
     #private;

package/dist/src/tasks/project-operating-view-service.js

@@ -4,17 +4,6 @@ import { TaskReadModelProjector } from "./task-read-model-projector.js";
 import { TaskDependencyService } from "./task-dependency-service.js";
 import { ProjectMonitoringService } from "./project-monitoring-service.js";
 //#region src/tasks/project-operating-view-service.ts
-function projectTaskLane(card) {
-	if (card.phase === "closed") return "done";
-	if (card.attention.some((item) => item.kind === "input_required" || item.kind === "approval_required")) return "needs_user";
-	if ([
-		"queued",
-		"running",
-		"verifying"
-	].includes(card.operationalState)) return "moving";
-	if (card.operationalState === "waiting" || card.operationalState === "blocked") return "waiting";
-	return "ready";
-}
 function summarizeProjectOperatingView(view) {
 	const counts = {
 		ready: 0,
@@ -23,8 +12,20 @@ function summarizeProjectOperatingView(view) {
 		needsUser: 0,
 		done: 0
 	};
-	for (const task of view.tasks) if (task.lane === "needs_user") counts.needsUser += 1;
-	else counts[task.lane] += 1;
+	for (const task of view.tasks) {
+		if (task.attention.some((item) => item.kind === "input_required" || item.kind === "approval_required")) {
+			counts.needsUser += 1;
+			continue;
+		}
+		if (task.phase === "closed") counts.done += 1;
+		else if ([
+			"queued",
+			"running",
+			"verifying"
+		].includes(task.operationalState)) counts.moving += 1;
+		else if (task.operationalState === "waiting" || task.operationalState === "blocked") counts.waiting += 1;
+		else counts.ready += 1;
+	}
 	return {
 		...view.digest,
 		counts,
@@ -48,7 +49,7 @@ var ProjectOperatingViewService = class {
 			const model = this.#projector.project(task);
 			const latest = this.#runs.getLatestRoot(task.id);
 			const receipt = latest ? this.#runs.getReceipt(latest.id) : void 0;
-			const base = {
+			return {
 				id: task.id,
 				title: task.title,
 				phase: task.phase,
@@ -63,20 +64,22 @@ var ProjectOperatingViewService = class {
 				...receipt ? { latestVerification: receipt.verification.status } : {},
 				updatedAt: task.updatedAt
 			};
-			return {
-				...base,
-				lane: projectTaskLane(base)
-			};
 		});
 		const recentResults = projectTasks.flatMap((task) => this.#runs.listReceipts(task.id, 10).map((receipt) => ({
 			taskId: task.id,
 			taskTitle: task.title,
 			receipt
 		}))).sort((a, b) => b.receipt.finalizedAt - a.receipt.finalizedAt).slice(0, 10);
-		const attentionCount = cards.filter((card) => card.lane === "needs_user").length;
+		const needsUser = (card) => card.attention.some((item) => item.kind === "input_required" || item.kind === "approval_required");
+		const moving = (card) => [
+			"queued",
+			"running",
+			"verifying"
+		].includes(card.operationalState);
+		const attentionCount = cards.filter((card) => card.attention.length > 0).length;
 		return {
 			project,
-			tasks: cards.sort((a, b) => b.updatedAt - a.updatedAt),
+			tasks: cards,
 			dependencyEdges: this.#dependencies.listProjectEdges(project.id),
 			blockers: cards.flatMap((card) => card.attention.map((item) => ({
 				id: item.sourceId ?? `${card.id}:${item.kind}`,
@@ -91,12 +94,12 @@ var ProjectOperatingViewService = class {
 			recentResults,
 			digest: {
 				health: cards.length === 0 ? "empty" : attentionCount > 0 ? "attention" : "healthy",
-				summary: cards.length === 0 ? "No tasks yet" : `${cards.filter((card) => card.lane === "moving").length} moving, ${attentionCount} need attention`,
-				recommendedAction: cards.find((card) => card.lane === "needs_user")?.attention[0]?.summary ?? cards.find((card) => card.lane === "moving")?.title ?? cards.find((card) => card.lane === "ready")?.title
+				summary: cards.length === 0 ? "No tasks yet" : `${cards.filter(moving).length} moving, ${attentionCount} need attention`,
+				recommendedAction: cards.find(needsUser)?.attention[0]?.summary ?? cards.find((card) => card.attention.length > 0)?.attention[0]?.summary ?? cards.find(moving)?.title ?? cards.find((card) => card.phase === "ready")?.title ?? cards.find((card) => card.phase === "backlog")?.title
 			},
 			monitoring: this.#monitoring.get(project.id)
 		};
 	}
 };
 //#endregion
-export { ProjectOperatingViewService, projectTaskLane, summarizeProjectOperatingView };
+export { ProjectOperatingViewService, summarizeProjectOperatingView };