@xopcai/xopc 0.0.178 → 0.0.180

package/dist/src/storage/sqlite/migrations/084_work_intake_lifecycle.sql

@@ -0,0 +1,26 @@
+CREATE TABLE work_intakes (
+  intake_id TEXT PRIMARY KEY,
+  idempotency_key TEXT NOT NULL UNIQUE,
+  request_fingerprint TEXT NOT NULL,
+  objective TEXT NOT NULL,
+  proposal_json TEXT NOT NULL,
+  session_key TEXT,
+  agent_id TEXT,
+  status TEXT NOT NULL CHECK (status IN ('proposed', 'confirmed', 'expired', 'cancelled')),
+  execution_mode TEXT NOT NULL DEFAULT 'run_now' CHECK (execution_mode IN ('create_only', 'run_now')),
+  project_id TEXT,
+  goal_id TEXT,
+  queue_id TEXT,
+  expires_at INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  confirmed_at INTEGER,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE SET NULL,
+  FOREIGN KEY (goal_id) REFERENCES goals(goal_id) ON DELETE SET NULL
+);
+
+CREATE INDEX idx_work_intakes_status_updated
+  ON work_intakes(status, updated_at DESC);
+
+CREATE INDEX idx_work_intakes_expires
+  ON work_intakes(status, expires_at);

package/dist/src/storage/sqlite/migrations/085_task_outcome_projection.sql

@@ -0,0 +1,19 @@
+ALTER TABLE task_outcomes ADD COLUMN completion_verdict TEXT
+  CHECK (completion_verdict IN ('achieved', 'partial', 'not_achieved'));
+ALTER TABLE task_outcomes ADD COLUMN completion_verdict_source TEXT
+  CHECK (completion_verdict_source IN ('system', 'user'));
+ALTER TABLE task_outcomes ADD COLUMN correction_text TEXT;
+ALTER TABLE task_outcomes ADD COLUMN projection_version INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE task_outcomes ADD COLUMN projected_at INTEGER;
+
+CREATE INDEX idx_task_outcomes_projection
+  ON task_outcomes(status, projection_version, completed_at);
+
+UPDATE task_outcomes
+SET completion_verdict = CASE
+      WHEN status = 'succeeded' AND verification_status = 'passed' THEN 'achieved'
+      WHEN status = 'succeeded' THEN 'partial'
+      ELSE 'not_achieved'
+    END,
+    completion_verdict_source = 'system'
+WHERE status != 'running';

package/dist/src/storage/sqlite/migrations/086_outcome_aggregates.sql

@@ -0,0 +1,168 @@
+CREATE TABLE outcomes (
+  outcome_id TEXT PRIMARY KEY,
+  objective TEXT NOT NULL,
+  user_status TEXT NOT NULL DEFAULT 'running'
+    CHECK (user_status IN ('running', 'needs_user', 'completed')),
+  internal_status TEXT NOT NULL DEFAULT 'captured'
+    CHECK (internal_status IN (
+      'captured', 'planning', 'running', 'verifying', 'continuing',
+      'needs_user', 'blocked', 'paused', 'completed', 'cancelled'
+    )),
+  importance TEXT NOT NULL DEFAULT 'normal'
+    CHECK (importance IN ('low', 'normal', 'high', 'critical')),
+  due_at INTEGER,
+  latest_contract_version INTEGER NOT NULL DEFAULT 1,
+  latest_receipt_run_id TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE INDEX idx_outcomes_status_updated
+  ON outcomes(user_status, updated_at DESC);
+
+CREATE TABLE outcome_contracts (
+  outcome_id TEXT NOT NULL,
+  version INTEGER NOT NULL,
+  objective TEXT NOT NULL,
+  deliverables_json TEXT NOT NULL DEFAULT '[]',
+  acceptance_criteria_json TEXT NOT NULL DEFAULT '[]',
+  constraints_json TEXT NOT NULL DEFAULT '[]',
+  approval_required_json TEXT NOT NULL DEFAULT '[]',
+  context_snapshot_id TEXT,
+  created_by TEXT NOT NULL DEFAULT 'system'
+    CHECK (created_by IN ('user', 'system')),
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (outcome_id, version),
+  FOREIGN KEY (outcome_id) REFERENCES outcomes(outcome_id) ON DELETE CASCADE
+);
+
+CREATE TABLE outcome_links (
+  outcome_id TEXT NOT NULL,
+  subject_kind TEXT NOT NULL
+    CHECK (subject_kind IN (
+      'project', 'goal', 'work_item', 'session', 'workflow',
+      'automation', 'artifact', 'source'
+    )),
+  subject_id TEXT NOT NULL,
+  relation TEXT NOT NULL DEFAULT 'supports',
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (outcome_id, subject_kind, subject_id),
+  FOREIGN KEY (outcome_id) REFERENCES outcomes(outcome_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_outcome_links_subject
+  ON outcome_links(subject_kind, subject_id);
+
+ALTER TABLE task_outcomes RENAME TO execution_receipts;
+
+DROP INDEX IF EXISTS idx_task_outcomes_session_started;
+DROP INDEX IF EXISTS idx_task_outcomes_status_started;
+DROP INDEX IF EXISTS idx_task_outcomes_project_updated;
+DROP INDEX IF EXISTS idx_task_outcomes_work_item_updated;
+DROP INDEX IF EXISTS idx_task_outcomes_unprojected;
+
+CREATE INDEX idx_execution_receipts_session_started
+  ON execution_receipts(session_key, started_at DESC);
+CREATE INDEX idx_execution_receipts_status_started
+  ON execution_receipts(status, started_at DESC);
+CREATE INDEX idx_execution_receipts_project_updated
+  ON execution_receipts(project_id, updated_at DESC);
+CREATE INDEX idx_execution_receipts_work_item_updated
+  ON execution_receipts(work_item_id, updated_at DESC);
+CREATE INDEX idx_execution_receipts_unprojected
+  ON execution_receipts(projection_version, completed_at DESC);
+
+ALTER TABLE work_intakes ADD COLUMN outcome_id TEXT;
+ALTER TABLE goals ADD COLUMN outcome_id TEXT;
+ALTER TABLE goals ADD COLUMN outcome_contract_version INTEGER NOT NULL DEFAULT 1;
+ALTER TABLE execution_receipts ADD COLUMN outcome_id TEXT;
+ALTER TABLE execution_receipts ADD COLUMN contract_version INTEGER;
+ALTER TABLE execution_receipts ADD COLUMN attempt INTEGER NOT NULL DEFAULT 1;
+ALTER TABLE execution_receipts ADD COLUMN strategy TEXT;
+
+CREATE INDEX idx_execution_receipts_outcome_started
+  ON execution_receipts(outcome_id, started_at DESC);
+
+CREATE UNIQUE INDEX idx_goals_outcome
+  ON goals(outcome_id)
+  WHERE outcome_id IS NOT NULL;
+
+INSERT INTO outcomes (
+  outcome_id, objective, user_status, internal_status, importance,
+  latest_contract_version, created_at, updated_at
+)
+SELECT
+  'outcome-goal-' || goals.goal_id,
+  COALESCE(goal_contracts.objective, goals.title),
+  CASE
+    WHEN goals.status IN ('done', 'archived') THEN 'completed'
+    WHEN goals.status IN ('blocked', 'needs_input') THEN 'needs_user'
+    ELSE 'running'
+  END,
+  CASE
+    WHEN goals.status IN ('done', 'archived') THEN 'completed'
+    WHEN goals.status = 'blocked' THEN 'blocked'
+    WHEN goals.status = 'needs_input' THEN 'needs_user'
+    WHEN goals.status = 'paused' THEN 'paused'
+    ELSE 'running'
+  END,
+  'normal',
+  COALESCE(goal_contracts.version, 1),
+  goals.created_at,
+  goals.updated_at
+FROM goals
+LEFT JOIN goal_contracts ON goal_contracts.goal_id = goals.goal_id;
+
+INSERT INTO outcome_contracts (
+  outcome_id, version, objective, deliverables_json, acceptance_criteria_json,
+  constraints_json, approval_required_json, created_by, created_at
+)
+SELECT
+  'outcome-goal-' || goals.goal_id,
+  COALESCE(goal_contracts.version, 1),
+  COALESCE(goal_contracts.objective, goals.title),
+  json_array(COALESCE(goal_contracts.objective, goals.title)),
+  COALESCE((
+    SELECT json_group_array(goal_checklist_items.text)
+    FROM goal_checklist_items
+    WHERE goal_checklist_items.goal_id = goals.goal_id
+  ), '[]'),
+  CASE
+    WHEN goal_contracts.scope_boundary IS NULL THEN '[]'
+    ELSE json_array(goal_contracts.scope_boundary)
+  END,
+  '[]',
+  'system',
+  goals.created_at
+FROM goals
+LEFT JOIN goal_contracts ON goal_contracts.goal_id = goals.goal_id;
+
+UPDATE goals
+SET outcome_id = 'outcome-goal-' || goal_id,
+    outcome_contract_version = COALESCE((
+      SELECT version FROM goal_contracts WHERE goal_contracts.goal_id = goals.goal_id
+    ), 1);
+
+INSERT INTO outcome_links (outcome_id, subject_kind, subject_id, relation, created_at)
+SELECT outcome_id, 'project', project_id, 'contains', created_at
+FROM goals WHERE project_id IS NOT NULL;
+
+INSERT INTO outcome_links (outcome_id, subject_kind, subject_id, relation, created_at)
+SELECT outcome_id, 'goal', goal_id, 'drives', created_at
+FROM goals;
+
+UPDATE work_intakes
+SET outcome_id = (
+  SELECT goals.outcome_id FROM goals WHERE goals.goal_id = work_intakes.goal_id
+)
+WHERE goal_id IS NOT NULL;
+
+UPDATE execution_receipts
+SET outcome_id = (
+  SELECT goals.outcome_id FROM goals WHERE goals.goal_id = execution_receipts.goal_id
+)
+WHERE goal_id IS NOT NULL;
+
+DROP TABLE goal_evidence_requirement_links;
+DROP TABLE goal_evidence_requirements;
+DROP TABLE goal_contracts;

package/dist/src/storage/sqlite/migrations/087_context_snapshots.sql

@@ -0,0 +1,21 @@
+CREATE TABLE context_snapshots (
+  snapshot_id TEXT PRIMARY KEY,
+  trace_id TEXT NOT NULL UNIQUE,
+  session_key TEXT NOT NULL,
+  query TEXT NOT NULL,
+  selected_items_json TEXT NOT NULL DEFAULT '[]',
+  rejected_items_json TEXT NOT NULL DEFAULT '[]',
+  consent_requests_json TEXT NOT NULL DEFAULT '[]',
+  relationship_policy_json TEXT NOT NULL DEFAULT '{}',
+  estimated_tokens INTEGER NOT NULL DEFAULT 0,
+  outcome_id TEXT,
+  run_id TEXT,
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY (outcome_id) REFERENCES outcomes(outcome_id) ON DELETE SET NULL,
+  FOREIGN KEY (run_id) REFERENCES execution_receipts(run_id) ON DELETE SET NULL
+);
+
+CREATE INDEX idx_context_snapshots_session_created
+  ON context_snapshots(session_key, created_at DESC);
+CREATE INDEX idx_context_snapshots_outcome
+  ON context_snapshots(outcome_id, created_at DESC);

package/dist/src/storage/sqlite/migrations/088_automation_execution_deadlines.sql

@@ -0,0 +1,5 @@
+ALTER TABLE automation_runs ADD COLUMN deadline_at_ms INTEGER;
+ALTER TABLE automation_runs ADD COLUMN current_phase TEXT;
+ALTER TABLE automation_runs ADD COLUMN cancel_requested_at_ms INTEGER;
+ALTER TABLE automation_runs ADD COLUMN cancel_confirmed_at_ms INTEGER;
+ALTER TABLE automation_runs ADD COLUMN termination_json TEXT;

package/dist/src/storage/sqlite/migrations/089_automation_run_leases.sql

@@ -0,0 +1,8 @@
+ALTER TABLE automation_runs ADD COLUMN heartbeat_at_ms INTEGER;
+ALTER TABLE automation_runs ADD COLUMN lease_owner TEXT;
+ALTER TABLE automation_runs ADD COLUMN lease_expires_at_ms INTEGER;
+ALTER TABLE automation_runs ADD COLUMN attempt_number INTEGER NOT NULL DEFAULT 1;
+ALTER TABLE automation_runs ADD COLUMN root_run_id TEXT;
+
+CREATE INDEX IF NOT EXISTS idx_automation_runs_lease
+  ON automation_runs(status, lease_expires_at_ms);

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 = 74;
+export declare const XOPC_DB_SCHEMA_VERSION = 89;
 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 = 74;
+const XOPC_DB_SCHEMA_VERSION = 89;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function resolveMigrationsDir(override) {
 	if (override) return override;
@@ -46,7 +46,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 ?? 74;
+	const targetVersion = options.targetVersion ?? 89;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -62,7 +62,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 74;
+	const appVersion = options.targetVersion ?? 89;
 	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 = 74;
+export const XOPC_DB_SCHEMA_VERSION = 89;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/notes-repository.js

@@ -177,6 +177,15 @@ function listNoteRecords(query = {}) {
 		params.push(query.groupId);
 	}
 	if (query.pendingTasksOnly) conditions.push(`kind = 'task' AND (task_done IS NULL OR task_done = 0)`);
+	if (query.projectId) {
+		conditions.push(`EXISTS (
+        SELECT 1 FROM object_links
+        WHERE relation = 'belongs_to'
+          AND from_kind = 'note' AND from_id = notes.note_id
+          AND to_kind = 'project' AND to_id = ?
+      )`);
+		params.push(query.projectId);
+	}
 	const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
 	const rows = db.prepare(`SELECT note_id, title, kind, status, payload_json, created_at, updated_at,
               pinned, tags_json, snippet, cover_attachment_id, voice_attachment_id,

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

@@ -31,7 +31,7 @@ function ensureXopcDatabaseSchema(db) {
 		bootstrapFreshDatabase(db);
 		currentVersion = 11;
 	}
-	applyPendingMigrations(db, { targetVersion: 74 });
+	applyPendingMigrations(db, { targetVersion: 89 });
 }
 //#endregion
 export { SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION, ensureSchemaMetaTable, ensureXopcDatabaseSchema, readSchemaVersion, readSchemaVersionForTest, setSchemaVersion };

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

@@ -536,6 +536,95 @@ CREATE TABLE IF NOT EXISTS activity_related_projects (
 CREATE INDEX IF NOT EXISTS idx_activity_related_projects_project
   ON activity_related_projects(project_id, activity_id);
 
+CREATE TABLE IF NOT EXISTS discussion_captures (
+  id                         TEXT PRIMARY KEY,
+  client_request_id          TEXT NOT NULL UNIQUE,
+  note_id                    TEXT NOT NULL UNIQUE,
+  project_id                 TEXT,
+  audio_attachment_id        TEXT,
+  source                     TEXT NOT NULL CHECK (source IN ('web', 'electron')),
+  status                     TEXT NOT NULL CHECK (status IN (
+    'recording',
+    'finalizing',
+    'completed',
+    'failed',
+    'cancelled'
+  )),
+  processing_stage           TEXT CHECK (processing_stage IN (
+    'original_upload',
+    'final_transcription',
+    'analysis',
+    'note_write'
+  )),
+  duration_ms                INTEGER,
+  expected_last_sequence     INTEGER,
+  mime_type                  TEXT,
+  audio_size_bytes           INTEGER,
+  audio_sha256               TEXT,
+  transcript_raw             TEXT,
+  transcript_sha256          TEXT,
+  transcript_language        TEXT,
+  stt_provider               TEXT,
+  analysis_json              TEXT,
+  analysis_input_hash        TEXT,
+  analyzer_model_ref         TEXT,
+  generated_title            TEXT,
+  project_inference_score    REAL,
+  project_inference_source   TEXT,
+  finalization_revision      INTEGER NOT NULL DEFAULT 0,
+  attempt_count              INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at            INTEGER,
+  lease_owner                TEXT,
+  lease_expires_at           INTEGER,
+  last_error_code            TEXT,
+  last_error_message         TEXT,
+  recording_started_at       INTEGER NOT NULL,
+  recording_finished_at      INTEGER,
+  created_at                 INTEGER NOT NULL,
+  updated_at                 INTEGER NOT NULL,
+  completed_at               INTEGER,
+  audio_deleted_at           INTEGER,
+  FOREIGN KEY (note_id) REFERENCES notes(note_id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE SET NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_discussion_captures_queue
+  ON discussion_captures(status, next_attempt_at, created_at);
+
+CREATE INDEX IF NOT EXISTS idx_discussion_captures_project
+  ON discussion_captures(project_id, updated_at DESC);
+
+CREATE TABLE IF NOT EXISTS discussion_transcript_segments (
+  discussion_id    TEXT NOT NULL,
+  sequence         INTEGER NOT NULL,
+  audio_sha256     TEXT NOT NULL,
+  audio_blob       BLOB,
+  started_at_ms    INTEGER NOT NULL,
+  ended_at_ms      INTEGER NOT NULL,
+  status           TEXT NOT NULL CHECK (status IN ('uploaded', 'transcribing', 'completed', 'failed')),
+  transcript       TEXT,
+  provider         TEXT,
+  attempt_count    INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at  INTEGER,
+  lease_owner      TEXT,
+  lease_expires_at INTEGER,
+  last_error       TEXT,
+  created_at       INTEGER NOT NULL,
+  updated_at       INTEGER NOT NULL,
+  PRIMARY KEY (discussion_id, sequence),
+  FOREIGN KEY (discussion_id) REFERENCES discussion_captures(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_discussion_segments_queue
+  ON discussion_transcript_segments(status, next_attempt_at, created_at);
+
+CREATE TABLE IF NOT EXISTS discussion_capture_settings (
+  workspace_id               TEXT PRIMARY KEY,
+  consent_policy_version     INTEGER NOT NULL,
+  consent_acknowledged_at    INTEGER,
+  updated_at                 INTEGER NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS goal_context_messages (
   goal_id           TEXT PRIMARY KEY,
   text              TEXT NOT NULL DEFAULT '',
@@ -545,17 +634,6 @@ CREATE TABLE IF NOT EXISTS goal_context_messages (
   FOREIGN KEY (goal_id) REFERENCES goals(goal_id) ON DELETE CASCADE
 );
 
-CREATE TABLE IF NOT EXISTS goal_contracts (
-  goal_id              TEXT PRIMARY KEY,
-  version              INTEGER NOT NULL DEFAULT 1,
-  objective            TEXT NOT NULL,
-  scope_boundary       TEXT,
-  evidence_plan_json   TEXT NOT NULL DEFAULT '[]',
-  created_at           INTEGER NOT NULL,
-  updated_at           INTEGER NOT NULL,
-  FOREIGN KEY (goal_id) REFERENCES goals(goal_id) ON DELETE CASCADE
-);
-
 CREATE TABLE IF NOT EXISTS goal_queue (
   queue_id       TEXT PRIMARY KEY,
   goal_id        TEXT NOT NULL,
@@ -652,39 +730,6 @@ CREATE TABLE IF NOT EXISTS goal_evidence (
 CREATE INDEX IF NOT EXISTS idx_goal_evidence_goal_created
   ON goal_evidence(goal_id, created_at DESC);
 
-CREATE TABLE IF NOT EXISTS goal_evidence_requirements (
-  requirement_id              TEXT PRIMARY KEY,
-  goal_id                     TEXT NOT NULL,
-  text                        TEXT NOT NULL,
-  status                      TEXT NOT NULL DEFAULT 'pending',
-  review_reason               TEXT,
-  review_confidence           REAL,
-  reviewed_by                 TEXT,
-  reviewed_at                 INTEGER,
-  requires_human_approval     INTEGER NOT NULL DEFAULT 1,
-  created_at                  INTEGER NOT NULL,
-  updated_at                  INTEGER NOT NULL,
-  sort_order                  INTEGER NOT NULL,
-  UNIQUE(goal_id, text),
-  FOREIGN KEY (goal_id) REFERENCES goals(goal_id) ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS idx_goal_evidence_requirements_goal_order
-  ON goal_evidence_requirements(goal_id, sort_order ASC);
-
-CREATE TABLE IF NOT EXISTS goal_evidence_requirement_links (
-  requirement_id TEXT NOT NULL,
-  evidence_id    TEXT NOT NULL,
-  linked_by      TEXT NOT NULL,
-  created_at     INTEGER NOT NULL,
-  PRIMARY KEY (requirement_id, evidence_id),
-  FOREIGN KEY (requirement_id) REFERENCES goal_evidence_requirements(requirement_id) ON DELETE CASCADE,
-  FOREIGN KEY (evidence_id) REFERENCES goal_evidence(evidence_id) ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS idx_goal_evidence_requirement_links_evidence
-  ON goal_evidence_requirement_links(evidence_id);
-
 CREATE TABLE IF NOT EXISTS goal_session_links (
   goal_id       TEXT NOT NULL,
   session_key   TEXT NOT NULL,

package/dist/src/storage/sqlite/session-repository.js

@@ -1,7 +1,7 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { validateSessionId } from "../../session/session-id.js";
 import { buildDefaultSessionMetadata } from "./session-metadata.js";
 import { buildGlobalSessionStats, metadataToSessionInsert, sessionRowToMetadata } from "./row-mappers.js";
-import { validateSessionId } from "../../session/session-id.js";
 import { escapeFts5Query } from "./fts.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/session-repository.ts

package/dist/src/storage/sqlite/session-task-plan-repository.d.ts

@@ -0,0 +1,20 @@
+export type SessionTaskPlanItemStatus = 'pending' | 'in_progress' | 'completed' | 'cancelled';
+export type SessionTaskPlanItem = {
+    id: string;
+    content: string;
+    status: SessionTaskPlanItemStatus;
+};
+export type SessionTaskPlan = {
+    sessionId: string;
+    planId: string;
+    items: SessionTaskPlanItem[];
+    revision: number;
+    updatedAt: number;
+};
+export declare function getSessionTaskPlan(sessionKey: string, planId?: string): SessionTaskPlan | undefined;
+export declare function setSessionTaskPlan(input: {
+    sessionKey: string;
+    planId?: string;
+    items: SessionTaskPlanItem[];
+    now?: number;
+}): SessionTaskPlan | undefined;

package/dist/src/storage/sqlite/session-task-plan-repository.js

@@ -0,0 +1,77 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { getCurrentSessionId } from "./session-repository.js";
+//#region src/storage/sqlite/session-task-plan-repository.ts
+const VALID_STATUSES = new Set([
+	"pending",
+	"in_progress",
+	"completed",
+	"cancelled"
+]);
+function parseItems(value) {
+	try {
+		const raw = JSON.parse(value);
+		if (!Array.isArray(raw)) return [];
+		return raw.flatMap((value) => {
+			if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+			const item = value;
+			const id = typeof item.id === "string" ? item.id.trim() : "";
+			const content = typeof item.content === "string" ? item.content.trim() : "";
+			const status = item.status;
+			return id && content && VALID_STATUSES.has(status) ? [{
+				id,
+				content,
+				status
+			}] : [];
+		});
+	} catch {
+		return [];
+	}
+}
+function fromRow(row) {
+	return {
+		sessionId: row.session_id,
+		planId: row.plan_id,
+		items: parseItems(row.items_json),
+		revision: row.revision,
+		updatedAt: row.updated_at
+	};
+}
+function getSessionTaskPlan(sessionKey, planId = "todo") {
+	const sessionId = getCurrentSessionId(sessionKey);
+	if (!sessionId) return void 0;
+	const row = getSqliteDatabase().prepare(`SELECT session_id, plan_id, items_json, revision, updated_at
+     FROM session_task_plans
+     WHERE session_id = ? AND plan_id = ?`).get(sessionId, planId);
+	return row ? fromRow(row) : void 0;
+}
+function setSessionTaskPlan(input) {
+	const planId = input.planId?.trim() || "todo";
+	if (!input.items.some((item) => item.status === "pending" || item.status === "in_progress")) {
+		deleteSessionTaskPlan(input.sessionKey, planId);
+		return;
+	}
+	const sessionId = getCurrentSessionId(input.sessionKey);
+	if (!sessionId) return void 0;
+	const now = input.now ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO session_task_plans (session_id, plan_id, items_json, revision, updated_at)
+       VALUES (?, ?, ?, 1, ?)
+       ON CONFLICT(session_id, plan_id) DO UPDATE SET
+         items_json = excluded.items_json,
+         revision = session_task_plans.revision + 1,
+         updated_at = excluded.updated_at`).run(sessionId, planId, JSON.stringify(input.items), now);
+	});
+	return getSessionTaskPlan(input.sessionKey, planId);
+}
+function deleteSessionTaskPlan(sessionKey, planId = "todo") {
+	const sessionId = getCurrentSessionId(sessionKey);
+	if (!sessionId) return false;
+	let deleted = false;
+	runSqliteWriteTransaction((db) => {
+		deleted = db.prepare(`DELETE FROM session_task_plans
+       WHERE session_id = ? AND plan_id = ?`).run(sessionId, planId).changes > 0;
+	});
+	return deleted;
+}
+//#endregion
+export { getSessionTaskPlan, setSessionTaskPlan };

package/dist/src/tui/backends/embedded-backend.d.ts

@@ -43,7 +43,9 @@ export declare class EmbeddedBackend implements TuiBackend {
     getActiveSignal(): AbortSignal | undefined;
     private getWorkflowRunService;
     private activeConfig;
+    private isWorkspaceTrusted;
     getStartupResources(sessionKey: string): Promise<import("../tui-backend.js").TuiStartupResources>;
+    refreshWorkspaceTrust(): void;
     startWorkflowRun(opts: TuiWorkflowRunStartRequest): Promise<TuiWorkflowRunStartResult>;
     resolveStartupProject(opts: {
         workspacePath: string;

package/dist/src/tui/backends/embedded-backend.js

@@ -10,6 +10,7 @@ import { init_agent_scope, listAgentEntries, normalizeAgentId } from "../../agen
 import { loadConfig, saveConfig } from "../../config/loader.js";
 import { effectiveWorkspacePathForSession } from "../../session/session-workspace.js";
 import { createCreateShareTool, isShareToolAvailable } from "../../agent/tools/create-share-tool.js";
+import { setTuiDefaultAgentConfig } from "../../commands/agents.config.js";
 import { ProjectService } from "../../projects/project-service.js";
 import { inferSuggestedProjectDefaultAgentId } from "../../projects/project-agent-suggestion.js";
 import "../../projects/index.js";
@@ -23,7 +24,6 @@ import { parseModelRef } from "../../agent/models/selection.js";
 import { buildReviewContext, resolveGitRoot } from "../../review/review-git.js";
 import { MessageBus, MessageBusShutdownError } from "../../infra/bus/queue.js";
 import "../../infra/bus/index.js";
-import { setTuiDefaultAgentConfig } from "../../commands/agents.config.js";
 import { getWorkspacePath } from "../../config/workspace-path-helpers.js";
 import "../../config/index.js";
 import { buildWorkflowChildTools } from "../../agent/workflow/workflow-child-tools.js";
@@ -140,12 +140,7 @@ var EmbeddedBackend = class {
 			sessionStore: sessionIndex.getStore(),
 			getWorkflowRunService: () => this.getWorkflowRunService(),
 			extensionRegistry: this.opts?.extensionRegistry,
-			isWorkspaceTrusted: (workspaceDir) => {
-				const explicit = this.opts?.isWorkspaceTrusted?.(workspaceDir);
-				if (explicit !== void 0 && explicit !== null) return explicit;
-				const implicit = this.opts?.implicitTrustedWorkspace;
-				if (implicit && isPathSameOrInside(implicit, workspaceDir)) return true;
-			}
+			isWorkspaceTrusted: (workspaceDir) => this.isWorkspaceTrusted(workspaceDir)
 		});
 		this.agent = agent;
 		await agent.start();
@@ -204,8 +199,17 @@ var EmbeddedBackend = class {
 	activeConfig() {
 		return this.config ?? this.opts?.config ?? loadConfig();
 	}
+	isWorkspaceTrusted(workspaceDir) {
+		const explicit = this.opts?.isWorkspaceTrusted?.(workspaceDir);
+		if (explicit !== void 0 && explicit !== null) return explicit;
+		const implicit = this.opts?.implicitTrustedWorkspace;
+		return Boolean(implicit && isPathSameOrInside(implicit, workspaceDir));
+	}
 	async getStartupResources(sessionKey) {
-		return collectTuiStartupResources(this.activeConfig(), sessionKey);
+		return collectTuiStartupResources(this.activeConfig(), sessionKey, { isWorkspaceTrusted: (workspaceDir) => this.isWorkspaceTrusted(workspaceDir) });
+	}
+	refreshWorkspaceTrust() {
+		this.agent?.refreshSkillsAfterTrustChange();
 	}
 	async startWorkflowRun(opts) {
 		await this.sessionIndexReady;

package/dist/src/tui/tui-backend.d.ts

@@ -226,6 +226,8 @@ export interface TuiBackend {
     }): Promise<TuiStartupProjectResult>;
     /** Load startup resources shown in `/start` and initial help. */
     getStartupResources?(sessionKey: string): Promise<TuiStartupResources>;
+    /** Re-evaluate project-scoped resources after a local trust decision changes. */
+    refreshWorkspaceTrust?(): void | Promise<void>;
     /** Fuzzy search files in this session's effective workspace. */
     searchWorkspaceFiles?(sessionKey: string, query: string, options?: {
         limit?: number;