@papi-ai/server 0.3.0-alpha.1 → 0.3.1-alpha

package/dist/index.js

@@ -1122,6 +1122,17 @@ function serializeReview(review) {
   );
   if (review.handoffRevision !== void 0) lines.push(`- **Handoff Revision:** ${review.handoffRevision}`);
   if (review.buildCommitSha) lines.push(`- **Build Commit SHA:** ${review.buildCommitSha}`);
+  if (review.autoReview) {
+    lines.push("", `#### Auto-Review (${review.autoReview.verdict})`);
+    lines.push(`> ${review.autoReview.summary}`);
+    if (review.autoReview.findings.length > 0) {
+      lines.push("");
+      for (const f of review.autoReview.findings) {
+        const loc = f.file ? f.line ? `${f.file}:${f.line}` : f.file : "";
+        lines.push(`- \`${f.severity}\`${loc ? ` ${loc}` : ""}: ${f.message}`);
+      }
+    }
+  }
   return lines.join("\n");
 }
 function prependReview(review, content) {
@@ -4344,6 +4355,7 @@ __export(dist_exports, {
   PgAdapter: () => PgAdapter,
   PgPapiAdapter: () => PgPapiAdapter,
   configFromEnv: () => configFromEnv,
+  ensureSchema: () => ensureSchema,
   normaliseComplexity: () => normaliseComplexity,
   normaliseEffort: () => normaliseEffort
 });
@@ -4374,6 +4386,29 @@ function definedEntries(obj) {
   }
   return result;
 }
+async function ensureSchema(config2) {
+  const sql = src_default(config2.connectionString, {
+    max: 1,
+    connect_timeout: 10
+  });
+  try {
+    const [result] = await sql`
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.tables
+        WHERE table_schema = 'public' AND table_name = 'projects'
+      ) as exists
+    `;
+    if (result.exists) {
+      return false;
+    }
+    console.error("[papi] Fresh database detected \u2014 creating PAPI schema...");
+    await sql.unsafe(BASE_SCHEMA_SQL);
+    console.error("[papi] \u2713 Schema created (31 tables)");
+    return true;
+  } finally {
+    await sql.end();
+  }
+}
 function rowToTask(row) {
   const task = {
     uuid: row.id,
@@ -4449,6 +4484,7 @@ function rowToReview(row) {
   };
   if (row.handoff_revision != null) review.handoffRevision = row.handoff_revision;
   if (row.build_commit_sha != null) review.buildCommitSha = row.build_commit_sha;
+  if (row.auto_review != null) review.autoReview = row.auto_review;
   return review;
 }
 function rowToActiveDecision(row) {
@@ -4644,12 +4680,13 @@ function normaliseComplexity(value) {
 function normaliseEffort(value) {
   return EFFORT_MAP[value] ?? value;
 }
-var PgAdapter, rowToCycle, COMPLEXITY_MAP, EFFORT_MAP, PgPapiAdapter;
+var PgAdapter, BASE_SCHEMA_SQL, rowToCycle, COMPLEXITY_MAP, EFFORT_MAP, PgPapiAdapter;
 var init_dist3 = __esm({
   "../adapter-pg/dist/index.js"() {
     "use strict";
     init_src();
     init_src();
+    init_src();
     init_dist2();
     PgAdapter = class {
       sql;
@@ -5169,6 +5206,736 @@ var init_dist3 = __esm({
         await this.sql.end();
       }
     };
+    BASE_SCHEMA_SQL = `
+-- =============================================================================
+-- Core tables (no foreign key dependencies)
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS projects (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  slug TEXT NOT NULL,
+  name TEXT NOT NULL,
+  repo_url TEXT,
+  papi_dir TEXT,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  site_url TEXT,
+  PRIMARY KEY (id),
+  UNIQUE (slug)
+);
+
+CREATE TABLE IF NOT EXISTS shared_milestones (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  title TEXT NOT NULL,
+  description TEXT DEFAULT ''::text NOT NULL,
+  status TEXT DEFAULT 'not_started'::text NOT NULL,
+  target_date DATE,
+  completed_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  archived_at TIMESTAMPTZ,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS shared_decisions (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  display_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  decision TEXT NOT NULL,
+  confidence TEXT NOT NULL,
+  status TEXT DEFAULT 'proposed'::text NOT NULL,
+  origin_project_id UUID NOT NULL REFERENCES projects(id),
+  evidence TEXT DEFAULT ''::text NOT NULL,
+  superseded_by_id UUID REFERENCES shared_decisions(id),
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  archived_at TIMESTAMPTZ,
+  PRIMARY KEY (id),
+  UNIQUE (display_id)
+);
+
+-- =============================================================================
+-- Project-scoped tables
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS product_briefs (
+  project_id UUID NOT NULL REFERENCES projects(id),
+  content TEXT DEFAULT ''::text NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  landscape_references JSONB,
+  user_journeys JSONB,
+  mvp_boundary TEXT,
+  assumptions_open_questions JSONB,
+  success_signals JSONB,
+  PRIMARY KEY (project_id)
+);
+
+CREATE TABLE IF NOT EXISTS cycles (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  number INTEGER NOT NULL,
+  status TEXT DEFAULT 'planning'::text NOT NULL,
+  start_date TIMESTAMPTZ NOT NULL,
+  end_date TIMESTAMPTZ,
+  goals TEXT[] DEFAULT '{}'::text[] NOT NULL,
+  board_health TEXT DEFAULT ''::text NOT NULL,
+  task_ids TEXT[] DEFAULT '{}'::uuid[] NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  context_hashes JSONB,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, number)
+);
+
+CREATE TABLE IF NOT EXISTS horizons (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  slug TEXT NOT NULL,
+  label TEXT NOT NULL,
+  description TEXT,
+  status TEXT DEFAULT 'active'::text NOT NULL,
+  sort_order INTEGER DEFAULT 0 NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  user_id UUID,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, slug)
+);
+
+CREATE TABLE IF NOT EXISTS stages (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  slug TEXT NOT NULL,
+  label TEXT NOT NULL,
+  description TEXT,
+  status TEXT DEFAULT 'active'::text NOT NULL,
+  sort_order INTEGER DEFAULT 0 NOT NULL,
+  horizon_id UUID NOT NULL REFERENCES horizons(id),
+  project_id UUID NOT NULL REFERENCES projects(id),
+  user_id UUID,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, slug)
+);
+
+CREATE TABLE IF NOT EXISTS phases (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  slug TEXT NOT NULL,
+  label TEXT NOT NULL,
+  description TEXT DEFAULT ''::text NOT NULL,
+  status TEXT DEFAULT 'Not Started'::text NOT NULL,
+  sort_order INTEGER DEFAULT 0 NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  stage_id UUID REFERENCES stages(id),
+  PRIMARY KEY (id),
+  UNIQUE (project_id, slug)
+);
+
+CREATE TABLE IF NOT EXISTS cycle_tasks (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  display_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  status TEXT DEFAULT 'Backlog'::text NOT NULL,
+  priority TEXT DEFAULT 'P3 Low'::text NOT NULL,
+  complexity TEXT DEFAULT 'Medium'::text NOT NULL,
+  module TEXT DEFAULT ''::text NOT NULL,
+  epic TEXT DEFAULT ''::text NOT NULL,
+  phase TEXT DEFAULT ''::text NOT NULL,
+  owner TEXT DEFAULT 'TBD'::text NOT NULL,
+  reviewed BOOLEAN DEFAULT false NOT NULL,
+  sprint INTEGER,
+  created_sprint INTEGER,
+  why TEXT,
+  depends_on TEXT,
+  notes TEXT,
+  closure_reason TEXT,
+  state_history JSONB DEFAULT '[]'::jsonb,
+  build_handoff JSONB,
+  build_report TEXT,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  task_type TEXT,
+  maturity TEXT,
+  cycle_number INTEGER,
+  created_cycle INTEGER,
+  stage_id UUID REFERENCES stages(id),
+  PRIMARY KEY (id),
+  UNIQUE (project_id, display_id)
+);
+
+CREATE TABLE IF NOT EXISTS active_decisions (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  display_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  confidence TEXT DEFAULT 'MEDIUM'::text NOT NULL,
+  superseded BOOLEAN DEFAULT false NOT NULL,
+  superseded_by TEXT,
+  created_sprint INTEGER,
+  modified_sprint INTEGER,
+  body TEXT DEFAULT ''::text NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  outcome TEXT DEFAULT 'pending'::text NOT NULL,
+  revision_count INTEGER DEFAULT 0 NOT NULL,
+  last_referenced_sprint INTEGER,
+  user_id UUID,
+  created_cycle INTEGER,
+  modified_cycle INTEGER,
+  last_referenced_cycle INTEGER,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, display_id)
+);
+
+CREATE TABLE IF NOT EXISTS north_stars (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  statement TEXT NOT NULL,
+  set_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  superseded_by_id UUID REFERENCES north_stars(id),
+  superseded_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS planning_log_entries (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  sprint_number INTEGER NOT NULL,
+  title TEXT NOT NULL,
+  content TEXT DEFAULT ''::text NOT NULL,
+  carry_forward TEXT,
+  notes TEXT,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  cycle_number INTEGER,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, sprint_number)
+);
+
+CREATE TABLE IF NOT EXISTS build_handoffs (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  display_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  task_title TEXT NOT NULL,
+  sprint INTEGER NOT NULL,
+  why_now TEXT DEFAULT ''::text NOT NULL,
+  scope TEXT[] DEFAULT '{}'::text[] NOT NULL,
+  scope_boundary TEXT[] DEFAULT '{}'::text[] NOT NULL,
+  acceptance_criteria TEXT[] DEFAULT '{}'::text[] NOT NULL,
+  security_considerations TEXT DEFAULT ''::text NOT NULL,
+  files_likely_touched TEXT[] DEFAULT '{}'::text[] NOT NULL,
+  effort TEXT DEFAULT 'M'::text NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, display_id)
+);
+
+CREATE TABLE IF NOT EXISTS build_reports (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  display_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  task_name TEXT NOT NULL,
+  date TEXT NOT NULL,
+  sprint INTEGER NOT NULL,
+  completed TEXT DEFAULT 'No'::text NOT NULL,
+  actual_effort TEXT NOT NULL,
+  estimated_effort TEXT NOT NULL,
+  scope_accuracy TEXT DEFAULT 'accurate'::text NOT NULL,
+  surprises TEXT DEFAULT ''::text NOT NULL,
+  discovered_issues TEXT DEFAULT ''::text NOT NULL,
+  architecture_notes TEXT DEFAULT ''::text NOT NULL,
+  commit_sha TEXT,
+  files_changed TEXT[] DEFAULT '{}'::text[],
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  related_decisions TEXT[] DEFAULT '{}'::text[],
+  user_id UUID,
+  handoff_accuracy JSONB,
+  corrections_count INTEGER DEFAULT 0 NOT NULL,
+  brief_implications JSONB,
+  cycle_number INTEGER,
+  dead_ends TEXT,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, display_id)
+);
+
+CREATE TABLE IF NOT EXISTS reviews (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  display_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  stage TEXT NOT NULL,
+  reviewer TEXT DEFAULT ''::text NOT NULL,
+  verdict TEXT NOT NULL,
+  sprint INTEGER NOT NULL,
+  date TEXT NOT NULL,
+  comments TEXT DEFAULT ''::text NOT NULL,
+  handoff_revision INTEGER,
+  build_commit_sha TEXT,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  cycle_number INTEGER,
+  auto_review JSONB,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, display_id)
+);
+
+CREATE TABLE IF NOT EXISTS registries (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  modules TEXT[] DEFAULT '{}'::text[] NOT NULL,
+  epics TEXT[] DEFAULT '{}'::text[] NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  PRIMARY KEY (id),
+  UNIQUE (project_id)
+);
+
+CREATE TABLE IF NOT EXISTS tool_call_metrics (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  timestamp TEXT NOT NULL,
+  tool TEXT NOT NULL,
+  duration_ms INTEGER NOT NULL,
+  input_tokens INTEGER,
+  output_tokens INTEGER,
+  estimated_cost_usd NUMERIC,
+  model TEXT,
+  sprint_number INTEGER,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  context_bytes INTEGER,
+  context_utilisation NUMERIC,
+  cycle_number INTEGER,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS cost_snapshots (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  sprint INTEGER NOT NULL,
+  date TEXT NOT NULL,
+  total_cost_usd NUMERIC DEFAULT 0 NOT NULL,
+  total_input_tokens BIGINT DEFAULT 0 NOT NULL,
+  total_output_tokens BIGINT DEFAULT 0 NOT NULL,
+  total_calls INTEGER DEFAULT 0 NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  cycle_number INTEGER,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, sprint)
+);
+
+CREATE TABLE IF NOT EXISTS cycle_metrics_snapshots (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  sprint INTEGER NOT NULL,
+  date TEXT NOT NULL,
+  accuracy JSONB DEFAULT '[]'::jsonb NOT NULL,
+  velocity JSONB DEFAULT '[]'::jsonb NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  user_id UUID,
+  cycle_number INTEGER,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, sprint)
+);
+
+CREATE TABLE IF NOT EXISTS strategy_reviews (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  sprint_number INTEGER NOT NULL,
+  title TEXT NOT NULL,
+  content TEXT NOT NULL,
+  notes TEXT,
+  board_health TEXT,
+  strategic_direction TEXT,
+  recommendations JSONB,
+  user_id UUID,
+  created_at TIMESTAMPTZ DEFAULT now(),
+  sprint_range TEXT,
+  full_analysis TEXT,
+  velocity_assessment TEXT,
+  structured_data JSONB,
+  cycle_number INTEGER,
+  cycle_range TEXT,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS strategy_recommendations (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  type TEXT NOT NULL,
+  status TEXT DEFAULT 'pending'::text NOT NULL,
+  content TEXT DEFAULT ''::text NOT NULL,
+  created_sprint INTEGER NOT NULL,
+  actioned_sprint INTEGER,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  dismissal_reason TEXT,
+  created_cycle INTEGER,
+  actioned_cycle INTEGER,
+  target TEXT,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS decision_events (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  decision_id TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  sprint INTEGER NOT NULL,
+  source TEXT NOT NULL,
+  source_ref TEXT,
+  detail TEXT,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  cycle_number INTEGER,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS decision_scores (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  decision_id TEXT NOT NULL,
+  sprint INTEGER NOT NULL,
+  effort SMALLINT NOT NULL,
+  risk SMALLINT NOT NULL,
+  reversibility SMALLINT NOT NULL,
+  scale_cost SMALLINT NOT NULL,
+  lock_in SMALLINT NOT NULL,
+  total_score SMALLINT,
+  rationale TEXT,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  cycle_number INTEGER,
+  PRIMARY KEY (id),
+  UNIQUE (project_id, decision_id, sprint)
+);
+
+CREATE TABLE IF NOT EXISTS entity_references (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  user_id UUID,
+  entity_type TEXT DEFAULT 'active_decision'::text NOT NULL,
+  entity_id TEXT NOT NULL,
+  reference_context TEXT NOT NULL,
+  tool_name TEXT NOT NULL,
+  sprint_number INTEGER NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  cycle_number INTEGER,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS dogfood_log (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  cycle_number INTEGER NOT NULL,
+  category TEXT NOT NULL,
+  content TEXT NOT NULL,
+  source_tool TEXT DEFAULT 'strategy_review'::text NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  status TEXT DEFAULT 'observed'::text NOT NULL,
+  linked_task_id TEXT,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS task_comments (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL,
+  task_id TEXT NOT NULL,
+  author TEXT DEFAULT 'human'::text NOT NULL,
+  content TEXT NOT NULL,
+  user_id UUID,
+  created_at TIMESTAMPTZ DEFAULT now(),
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS task_transitions (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  project_id UUID NOT NULL REFERENCES projects(id),
+  task_id VARCHAR(50) NOT NULL,
+  from_status VARCHAR(50) NOT NULL,
+  to_status VARCHAR(50) NOT NULL,
+  changed_by VARCHAR(100) DEFAULT 'system'::character varying NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  PRIMARY KEY (id)
+);
+
+-- =============================================================================
+-- Cross-project tables
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS acknowledgements (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  decision_id UUID NOT NULL REFERENCES shared_decisions(id),
+  project_id UUID NOT NULL REFERENCES projects(id),
+  status TEXT DEFAULT 'pending'::text NOT NULL,
+  comments TEXT,
+  responded_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  PRIMARY KEY (id),
+  UNIQUE (decision_id, project_id)
+);
+
+CREATE TABLE IF NOT EXISTS milestone_dependencies (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  milestone_id UUID NOT NULL REFERENCES shared_milestones(id),
+  depends_on_id UUID NOT NULL REFERENCES shared_milestones(id),
+  PRIMARY KEY (id),
+  UNIQUE (milestone_id, depends_on_id)
+);
+
+CREATE TABLE IF NOT EXISTS project_contributions (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  milestone_id UUID NOT NULL REFERENCES shared_milestones(id),
+  project_id UUID NOT NULL REFERENCES projects(id),
+  status TEXT DEFAULT 'blocked'::text NOT NULL,
+  required_phases TEXT[] DEFAULT '{}'::text[] NOT NULL,
+  notes TEXT,
+  delivered_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  PRIMARY KEY (id),
+  UNIQUE (milestone_id, project_id)
+);
+
+CREATE TABLE IF NOT EXISTS conflict_alerts (
+  id UUID DEFAULT gen_random_uuid() NOT NULL,
+  conflict_type TEXT NOT NULL,
+  title TEXT NOT NULL,
+  description TEXT NOT NULL,
+  status TEXT DEFAULT 'open'::text NOT NULL,
+  decision_a_id UUID REFERENCES shared_decisions(id),
+  decision_b_id UUID REFERENCES shared_decisions(id),
+  north_star_id UUID REFERENCES north_stars(id),
+  resolution_decision_id UUID REFERENCES shared_decisions(id),
+  raised_by TEXT NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
+  resolved_at TIMESTAMPTZ,
+  PRIMARY KEY (id)
+);
+
+-- =============================================================================
+-- Indexes
+-- =============================================================================
+
+CREATE INDEX IF NOT EXISTS idx_cycles_project ON cycles(project_id);
+CREATE INDEX IF NOT EXISTS idx_cycles_status ON cycles(status);
+CREATE INDEX IF NOT EXISTS idx_cycle_tasks_project ON cycle_tasks(project_id);
+CREATE INDEX IF NOT EXISTS idx_cycle_tasks_status ON cycle_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_cycle_tasks_sprint ON cycle_tasks(sprint);
+CREATE INDEX IF NOT EXISTS idx_cycle_tasks_priority ON cycle_tasks(priority);
+CREATE INDEX IF NOT EXISTS idx_cycle_tasks_phase ON cycle_tasks(phase);
+CREATE INDEX IF NOT EXISTS idx_cycle_tasks_user_id ON cycle_tasks(user_id);
+CREATE INDEX IF NOT EXISTS idx_phases_project ON phases(project_id);
+CREATE INDEX IF NOT EXISTS idx_phases_stage_id ON phases(stage_id);
+CREATE INDEX IF NOT EXISTS idx_horizons_project_id ON horizons(project_id);
+CREATE INDEX IF NOT EXISTS idx_stages_project_id ON stages(project_id);
+CREATE INDEX IF NOT EXISTS idx_stages_horizon_id ON stages(horizon_id);
+CREATE INDEX IF NOT EXISTS idx_active_decisions_project ON active_decisions(project_id);
+CREATE INDEX IF NOT EXISTS idx_active_decisions_confidence ON active_decisions(confidence);
+CREATE INDEX IF NOT EXISTS idx_active_decisions_user_id ON active_decisions(user_id);
+CREATE INDEX IF NOT EXISTS idx_north_stars_project ON north_stars(project_id);
+CREATE INDEX IF NOT EXISTS idx_north_stars_active ON north_stars(project_id) WHERE superseded_by_id IS NULL;
+CREATE INDEX IF NOT EXISTS idx_planning_log_entries_project ON planning_log_entries(project_id);
+CREATE INDEX IF NOT EXISTS idx_planning_log_entries_sprint ON planning_log_entries(sprint_number);
+CREATE INDEX IF NOT EXISTS idx_build_handoffs_project ON build_handoffs(project_id);
+CREATE INDEX IF NOT EXISTS idx_build_handoffs_sprint ON build_handoffs(sprint);
+CREATE INDEX IF NOT EXISTS idx_build_handoffs_task_id ON build_handoffs(task_id);
+CREATE INDEX IF NOT EXISTS idx_build_reports_project ON build_reports(project_id);
+CREATE INDEX IF NOT EXISTS idx_build_reports_sprint ON build_reports(sprint);
+CREATE INDEX IF NOT EXISTS idx_build_reports_task_id ON build_reports(task_id);
+CREATE INDEX IF NOT EXISTS idx_build_reports_user_id ON build_reports(user_id);
+CREATE INDEX IF NOT EXISTS idx_reviews_project ON reviews(project_id);
+CREATE INDEX IF NOT EXISTS idx_reviews_sprint ON reviews(sprint);
+CREATE INDEX IF NOT EXISTS idx_reviews_task_id ON reviews(task_id);
+CREATE INDEX IF NOT EXISTS idx_registries_project ON registries(project_id);
+CREATE INDEX IF NOT EXISTS idx_tool_call_metrics_project ON tool_call_metrics(project_id);
+CREATE INDEX IF NOT EXISTS idx_tool_call_metrics_sprint ON tool_call_metrics(sprint_number);
+CREATE INDEX IF NOT EXISTS idx_tool_call_metrics_tool ON tool_call_metrics(tool);
+CREATE INDEX IF NOT EXISTS idx_tool_call_metrics_user_id ON tool_call_metrics(user_id);
+CREATE INDEX IF NOT EXISTS idx_cost_snapshots_project ON cost_snapshots(project_id);
+CREATE INDEX IF NOT EXISTS idx_cost_snapshots_user_id ON cost_snapshots(user_id);
+CREATE INDEX IF NOT EXISTS idx_cycle_metrics_snapshots_project ON cycle_metrics_snapshots(project_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_strategy_reviews_project_sprint ON strategy_reviews(project_id, sprint_number);
+CREATE INDEX IF NOT EXISTS idx_strategy_reviews_user_id ON strategy_reviews(user_id);
+CREATE INDEX IF NOT EXISTS idx_strategy_recommendations_sprint ON strategy_recommendations(project_id, created_sprint);
+CREATE INDEX IF NOT EXISTS idx_strategy_recommendations_project_status ON strategy_recommendations(project_id, status);
+CREATE INDEX IF NOT EXISTS idx_decision_events_project_decision ON decision_events(project_id, decision_id);
+CREATE INDEX IF NOT EXISTS idx_decision_events_project_sprint ON decision_events(project_id, sprint);
+CREATE INDEX IF NOT EXISTS idx_decision_scores_project_decision ON decision_scores(project_id, decision_id);
+CREATE INDEX IF NOT EXISTS idx_entity_references_project ON entity_references(project_id);
+CREATE INDEX IF NOT EXISTS idx_entity_references_entity ON entity_references(entity_id, entity_type);
+CREATE INDEX IF NOT EXISTS idx_entity_references_sprint ON entity_references(sprint_number);
+CREATE INDEX IF NOT EXISTS idx_dogfood_log_project ON dogfood_log(project_id);
+CREATE INDEX IF NOT EXISTS idx_dogfood_log_cycle ON dogfood_log(cycle_number);
+CREATE INDEX IF NOT EXISTS idx_dogfood_log_status ON dogfood_log(project_id, status) WHERE status = 'observed';
+CREATE INDEX IF NOT EXISTS idx_task_comments_project_task ON task_comments(project_id, task_id);
+CREATE INDEX IF NOT EXISTS idx_task_comments_user_id ON task_comments(user_id);
+CREATE INDEX IF NOT EXISTS idx_task_transitions_project_task ON task_transitions(project_id, task_id);
+CREATE INDEX IF NOT EXISTS idx_task_transitions_created ON task_transitions(project_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_acknowledgements_decision ON acknowledgements(decision_id);
+CREATE INDEX IF NOT EXISTS idx_acknowledgements_project ON acknowledgements(project_id);
+CREATE INDEX IF NOT EXISTS idx_shared_decisions_origin_project ON shared_decisions(origin_project_id);
+CREATE INDEX IF NOT EXISTS idx_shared_decisions_status ON shared_decisions(status);
+CREATE INDEX IF NOT EXISTS idx_shared_decisions_superseded_by ON shared_decisions(superseded_by_id);
+CREATE INDEX IF NOT EXISTS idx_shared_milestones_status ON shared_milestones(status);
+CREATE INDEX IF NOT EXISTS idx_milestone_deps_milestone ON milestone_dependencies(milestone_id);
+CREATE INDEX IF NOT EXISTS idx_milestone_deps_depends_on ON milestone_dependencies(depends_on_id);
+CREATE INDEX IF NOT EXISTS idx_project_contributions_project ON project_contributions(project_id);
+CREATE INDEX IF NOT EXISTS idx_project_contributions_milestone ON project_contributions(milestone_id);
+CREATE INDEX IF NOT EXISTS idx_project_contributions_status ON project_contributions(status);
+CREATE INDEX IF NOT EXISTS idx_conflict_alerts_decision_a ON conflict_alerts(decision_a_id);
+CREATE INDEX IF NOT EXISTS idx_conflict_alerts_decision_b ON conflict_alerts(decision_b_id);
+CREATE INDEX IF NOT EXISTS idx_conflict_alerts_north_star ON conflict_alerts(north_star_id);
+CREATE INDEX IF NOT EXISTS idx_conflict_alerts_resolution ON conflict_alerts(resolution_decision_id);
+CREATE INDEX IF NOT EXISTS idx_conflict_alerts_status ON conflict_alerts(status);
+CREATE INDEX IF NOT EXISTS idx_conflict_alerts_type ON conflict_alerts(conflict_type);
+
+-- =============================================================================
+-- Row Level Security \u2014 permissive for alpha (service role bypasses RLS)
+-- =============================================================================
+
+ALTER TABLE projects ENABLE ROW LEVEL SECURITY;
+ALTER TABLE cycles ENABLE ROW LEVEL SECURITY;
+ALTER TABLE cycle_tasks ENABLE ROW LEVEL SECURITY;
+ALTER TABLE phases ENABLE ROW LEVEL SECURITY;
+ALTER TABLE horizons ENABLE ROW LEVEL SECURITY;
+ALTER TABLE stages ENABLE ROW LEVEL SECURITY;
+ALTER TABLE active_decisions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE north_stars ENABLE ROW LEVEL SECURITY;
+ALTER TABLE planning_log_entries ENABLE ROW LEVEL SECURITY;
+ALTER TABLE build_handoffs ENABLE ROW LEVEL SECURITY;
+ALTER TABLE build_reports ENABLE ROW LEVEL SECURITY;
+ALTER TABLE reviews ENABLE ROW LEVEL SECURITY;
+ALTER TABLE registries ENABLE ROW LEVEL SECURITY;
+ALTER TABLE tool_call_metrics ENABLE ROW LEVEL SECURITY;
+ALTER TABLE cost_snapshots ENABLE ROW LEVEL SECURITY;
+ALTER TABLE cycle_metrics_snapshots ENABLE ROW LEVEL SECURITY;
+ALTER TABLE strategy_reviews ENABLE ROW LEVEL SECURITY;
+ALTER TABLE strategy_recommendations ENABLE ROW LEVEL SECURITY;
+ALTER TABLE decision_events ENABLE ROW LEVEL SECURITY;
+ALTER TABLE decision_scores ENABLE ROW LEVEL SECURITY;
+ALTER TABLE entity_references ENABLE ROW LEVEL SECURITY;
+ALTER TABLE dogfood_log ENABLE ROW LEVEL SECURITY;
+ALTER TABLE task_comments ENABLE ROW LEVEL SECURITY;
+ALTER TABLE task_transitions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE product_briefs ENABLE ROW LEVEL SECURITY;
+ALTER TABLE acknowledgements ENABLE ROW LEVEL SECURITY;
+ALTER TABLE shared_decisions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE shared_milestones ENABLE ROW LEVEL SECURITY;
+ALTER TABLE milestone_dependencies ENABLE ROW LEVEL SECURITY;
+ALTER TABLE project_contributions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE conflict_alerts ENABLE ROW LEVEL SECURITY;
+
+DO $$ BEGIN
+  CREATE POLICY "allow_all_projects" ON projects FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_cycles" ON cycles FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_cycle_tasks" ON cycle_tasks FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_phases" ON phases FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_horizons" ON horizons FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_stages" ON stages FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_active_decisions" ON active_decisions FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_north_stars" ON north_stars FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_planning_log_entries" ON planning_log_entries FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_build_handoffs" ON build_handoffs FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_build_reports" ON build_reports FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_reviews" ON reviews FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_registries" ON registries FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_tool_call_metrics" ON tool_call_metrics FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_cost_snapshots" ON cost_snapshots FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_cycle_metrics_snapshots" ON cycle_metrics_snapshots FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_strategy_reviews" ON strategy_reviews FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_strategy_recommendations" ON strategy_recommendations FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_decision_events" ON decision_events FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_decision_scores" ON decision_scores FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_entity_references" ON entity_references FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_dogfood_log" ON dogfood_log FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_task_comments" ON task_comments FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_task_transitions" ON task_transitions FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_product_briefs" ON product_briefs FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_acknowledgements" ON acknowledgements FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_shared_decisions" ON shared_decisions FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_shared_milestones" ON shared_milestones FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_milestone_dependencies" ON milestone_dependencies FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_project_contributions" ON project_contributions FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+DO $$ BEGIN
+  CREATE POLICY "allow_all_conflict_alerts" ON conflict_alerts FOR ALL USING (true) WITH CHECK (true);
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+`;
     rowToCycle = rowToSprint;
     COMPLEXITY_MAP = {
       "XS": "Small",
@@ -5596,6 +6363,12 @@ ${newParts.join("\n")}` : newParts.join("\n");
         modified_sprint = EXCLUDED.modified_sprint,
         revision_count = active_decisions.revision_count + 1,
         outcome = CASE WHEN active_decisions.outcome = 'pending' THEN 'revised' ELSE active_decisions.outcome END
+    `;
+      }
+      async deleteActiveDecision(id) {
+        await this.sql`
+      DELETE FROM active_decisions
+      WHERE project_id = ${this.projectId} AND display_id = ${id}
     `;
       }
       // -------------------------------------------------------------------------
@@ -5819,12 +6592,13 @@ ${newParts.join("\n")}` : newParts.join("\n");
         await this.sql`
       INSERT INTO reviews (
         project_id, display_id, task_id, stage, reviewer, verdict,
-        sprint, date, comments, handoff_revision, build_commit_sha
+        sprint, date, comments, handoff_revision, build_commit_sha, auto_review
       ) VALUES (
         ${this.projectId}, ${displayId}, ${review.taskId}, ${review.stage},
         ${review.reviewer}, ${review.verdict}, ${review.sprint},
         ${review.date}, ${review.comments},
-        ${review.handoffRevision ?? null}, ${review.buildCommitSha ?? null}
+        ${review.handoffRevision ?? null}, ${review.buildCommitSha ?? null},
+        ${review.autoReview ? JSON.stringify(review.autoReview) : null}
       )
     `;
       }
@@ -6854,6 +7628,331 @@ ${newParts.join("\n")}` : newParts.join("\n");
   }
 });
 
+// src/proxy-adapter.ts
+var proxy_adapter_exports = {};
+__export(proxy_adapter_exports, {
+  ProxyPapiAdapter: () => ProxyPapiAdapter
+});
+var ProxyPapiAdapter;
+var init_proxy_adapter = __esm({
+  "src/proxy-adapter.ts"() {
+    "use strict";
+    ProxyPapiAdapter = class {
+      endpoint;
+      apiKey;
+      projectId;
+      constructor(config2) {
+        this.endpoint = config2.endpoint.replace(/\/$/, "");
+        this.apiKey = config2.apiKey;
+        this.projectId = config2.projectId;
+      }
+      /**
+       * Send an adapter method call to the proxy Edge Function.
+       * Serializes { projectId, method, args } and deserializes the response.
+       */
+      async invoke(method, args = []) {
+        const url = `${this.endpoint}/invoke`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify({
+            projectId: this.projectId,
+            method,
+            args
+          })
+        });
+        if (!response.ok) {
+          const errorBody = await response.text();
+          let message;
+          try {
+            const parsed = JSON.parse(errorBody);
+            message = parsed.error ?? errorBody;
+          } catch {
+            message = errorBody;
+          }
+          throw new Error(`Proxy error (${response.status}) on ${method}: ${message}`);
+        }
+        const body = await response.json();
+        if (!body.ok && body.error) {
+          throw new Error(`Proxy error on ${method}: ${body.error}`);
+        }
+        return body.result;
+      }
+      /** Check if the proxy is reachable. */
+      async probeConnection() {
+        try {
+          const response = await fetch(`${this.endpoint}/health`, {
+            signal: AbortSignal.timeout(5e3)
+          });
+          return response.ok;
+        } catch {
+          return false;
+        }
+      }
+      // --- Planning & Health ---
+      readPlanningLog() {
+        return this.invoke("readPlanningLog");
+      }
+      getSprintHealth() {
+        return this.invoke("getSprintHealth");
+      }
+      getActiveDecisions() {
+        return this.invoke("getActiveDecisions");
+      }
+      getSprintLog(limit) {
+        return this.invoke("getSprintLog", [limit]);
+      }
+      getSprintLogSince(sprintNumber) {
+        return this.invoke("getSprintLogSince", [sprintNumber]);
+      }
+      setSprintHealth(updates) {
+        return this.invoke("setSprintHealth", [updates]);
+      }
+      writeSprintLogEntry(entry) {
+        return this.invoke("writeSprintLogEntry", [entry]);
+      }
+      updateActiveDecision(id, body, sprintNumber) {
+        return this.invoke("updateActiveDecision", [id, body, sprintNumber]);
+      }
+      upsertActiveDecision(id, body, title, confidence, sprintNumber) {
+        return this.invoke("upsertActiveDecision", [id, body, title, confidence, sprintNumber]);
+      }
+      deleteActiveDecision(id) {
+        return this.invoke("deleteActiveDecision", [id]);
+      }
+      // --- Board / Tasks ---
+      queryBoard(options) {
+        return this.invoke("queryBoard", [options]);
+      }
+      getTask(id) {
+        return this.invoke("getTask", [id]);
+      }
+      getTasks(ids) {
+        return this.invoke("getTasks", [ids]);
+      }
+      createTask(task) {
+        return this.invoke("createTask", [task]);
+      }
+      updateTask(id, updates, options) {
+        return this.invoke("updateTask", [id, updates, options]);
+      }
+      updateTaskStatus(id, status) {
+        return this.invoke("updateTaskStatus", [id, status]);
+      }
+      recordTransition(taskId, fromStatus, toStatus, changedBy) {
+        return this.invoke("recordTransition", [taskId, fromStatus, toStatus, changedBy]);
+      }
+      // --- Build Reports ---
+      appendBuildReport(report) {
+        return this.invoke("appendBuildReport", [report]);
+      }
+      getRecentBuildReports(count) {
+        return this.invoke("getRecentBuildReports", [count]);
+      }
+      getBuildReportsSince(sprintNumber) {
+        return this.invoke("getBuildReportsSince", [sprintNumber]);
+      }
+      // --- Reviews ---
+      getRecentReviews(count) {
+        return this.invoke("getRecentReviews", [count]);
+      }
+      writeReview(review) {
+        return this.invoke("writeReview", [review]);
+      }
+      // --- Compression / Archive ---
+      compressSprintLog(threshold, summary) {
+        return this.invoke("compressSprintLog", [threshold, summary]);
+      }
+      compressBuildReports(threshold, summary) {
+        return this.invoke("compressBuildReports", [threshold, summary]);
+      }
+      archiveTasks(phases, statuses) {
+        return this.invoke("archiveTasks", [phases, statuses]);
+      }
+      // --- Product Brief & Discovery ---
+      readProductBrief() {
+        return this.invoke("readProductBrief");
+      }
+      updateProductBrief(content) {
+        return this.invoke("updateProductBrief", [content]);
+      }
+      readDiscoveryCanvas() {
+        return this.invoke("readDiscoveryCanvas");
+      }
+      updateDiscoveryCanvas(canvas) {
+        return this.invoke("updateDiscoveryCanvas", [canvas]);
+      }
+      // --- Phases & Hierarchy ---
+      readPhases() {
+        return this.invoke("readPhases");
+      }
+      writePhases(phases) {
+        return this.invoke("writePhases", [phases]);
+      }
+      readHorizons() {
+        return this.invoke("readHorizons");
+      }
+      readStages(horizonId) {
+        return this.invoke("readStages", [horizonId]);
+      }
+      updateStageStatus(stageId, status) {
+        return this.invoke("updateStageStatus", [stageId, status]);
+      }
+      updateHorizonStatus(horizonId, status) {
+        return this.invoke("updateHorizonStatus", [horizonId, status]);
+      }
+      getActiveStage() {
+        return this.invoke("getActiveStage");
+      }
+      createHorizon(horizon) {
+        return this.invoke("createHorizon", [horizon]);
+      }
+      createStage(stage) {
+        return this.invoke("createStage", [stage]);
+      }
+      linkPhasesToStage(stageId) {
+        return this.invoke("linkPhasesToStage", [stageId]);
+      }
+      // --- Metrics ---
+      appendToolMetric(metric) {
+        return this.invoke("appendToolMetric", [metric]);
+      }
+      readToolMetrics() {
+        return this.invoke("readToolMetrics");
+      }
+      getCostSummary(sprintNumber) {
+        return this.invoke("getCostSummary", [sprintNumber]);
+      }
+      writeCostSnapshot(snapshot) {
+        return this.invoke("writeCostSnapshot", [snapshot]);
+      }
+      getCostSnapshots() {
+        return this.invoke("getCostSnapshots");
+      }
+      appendSprintMetrics(snapshot) {
+        return this.invoke("appendSprintMetrics", [snapshot]);
+      }
+      readSprintMetrics() {
+        return this.invoke("readSprintMetrics");
+      }
+      // --- Sprints / Cycles ---
+      readSprints() {
+        return this.invoke("readSprints");
+      }
+      createSprint(sprint) {
+        return this.invoke("createSprint", [sprint]);
+      }
+      readCycles() {
+        return this.invoke("readCycles");
+      }
+      createCycle(cycle) {
+        return this.invoke("createCycle", [cycle]);
+      }
+      getContextHashes(sprintNumber) {
+        return this.invoke("getContextHashes", [sprintNumber]);
+      }
+      // --- Registries ---
+      readRegistries() {
+        return this.invoke("readRegistries");
+      }
+      updateRegistries(registries) {
+        return this.invoke("updateRegistries", [registries]);
+      }
+      // --- Recommendations ---
+      writeRecommendation(rec) {
+        return this.invoke("writeRecommendation", [rec]);
+      }
+      getPendingRecommendations() {
+        return this.invoke("getPendingRecommendations");
+      }
+      actionRecommendation(id, sprintNumber) {
+        return this.invoke("actionRecommendation", [id, sprintNumber]);
+      }
+      // --- Decision Events & Scores ---
+      appendDecisionEvent(event) {
+        return this.invoke("appendDecisionEvent", [event]);
+      }
+      getDecisionEvents(decisionId, limit) {
+        return this.invoke("getDecisionEvents", [decisionId, limit]);
+      }
+      getDecisionEventsSince(sprint) {
+        return this.invoke("getDecisionEventsSince", [sprint]);
+      }
+      writeDecisionScore(score) {
+        return this.invoke("writeDecisionScore", [score]);
+      }
+      getDecisionScores(decisionId) {
+        return this.invoke("getDecisionScores", [decisionId]);
+      }
+      getLatestDecisionScores() {
+        return this.invoke("getLatestDecisionScores");
+      }
+      logEntityReferences(refs) {
+        return this.invoke("logEntityReferences", [refs]);
+      }
+      getDecisionUsage(currentSprint) {
+        return this.invoke("getDecisionUsage", [currentSprint]);
+      }
+      getContextUtilisation() {
+        return this.invoke("getContextUtilisation");
+      }
+      // --- Strategy Reviews ---
+      writeStrategyReview(review) {
+        return this.invoke("writeStrategyReview", [review]);
+      }
+      getLastStrategyReviewSprint() {
+        return this.invoke("getLastStrategyReviewSprint");
+      }
+      getStrategyReviews(limit, includeFullAnalysis) {
+        return this.invoke("getStrategyReviews", [limit, includeFullAnalysis]);
+      }
+      // --- Dogfood ---
+      writeDogfoodEntries(entries) {
+        return this.invoke("writeDogfoodEntries", [entries]);
+      }
+      getDogfoodLog(limit) {
+        return this.invoke("getDogfoodLog", [limit]);
+      }
+      getUnactionedDogfoodEntries(limit) {
+        return this.invoke("getUnactionedDogfoodEntries", [limit]);
+      }
+      updateDogfoodEntryStatus(id, status, linkedTaskId) {
+        return this.invoke("updateDogfoodEntryStatus", [id, status, linkedTaskId]);
+      }
+      // --- North Star ---
+      getCurrentNorthStar() {
+        return this.invoke("getCurrentNorthStar");
+      }
+      getNorthStarSetCycle() {
+        return this.invoke("getNorthStarSetCycle");
+      }
+      // --- Optional pg-only methods ---
+      getEstimationCalibration() {
+        return this.invoke("getEstimationCalibration");
+      }
+      getRecentTaskComments(limit) {
+        return this.invoke("getRecentTaskComments", [limit]);
+      }
+      getRecommendationEffectiveness() {
+        return this.invoke("getRecommendationEffectiveness");
+      }
+      getPlanContextSummary() {
+        return this.invoke("getPlanContextSummary");
+      }
+      projectExists() {
+        return this.invoke("projectExists");
+      }
+      // --- Atomic plan write-back ---
+      planWriteBack(payload) {
+        return this.invoke("planWriteBack", [payload]);
+      }
+    };
+  }
+});
+
 // src/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -6872,7 +7971,10 @@ function loadConfig() {
   const baseBranch = process.env.PAPI_BASE_BRANCH ?? "main";
   const autoPR = process.env.PAPI_AUTO_PR !== "false";
   const papiEndpoint = process.env.PAPI_ENDPOINT;
-  const adapterType = papiEndpoint ? "pg" : process.env.PAPI_ADAPTER ?? "md";
+  const dataEndpoint = process.env.PAPI_DATA_ENDPOINT;
+  const databaseUrl = process.env.DATABASE_URL;
+  const explicitAdapter = process.env.PAPI_ADAPTER;
+  const adapterType = papiEndpoint ? "pg" : databaseUrl && explicitAdapter === "pg" ? "pg" : dataEndpoint ? "proxy" : explicitAdapter ? explicitAdapter : databaseUrl ? "pg" : "proxy";
   return {
     projectRoot,
     papiDir: path.join(projectRoot, ".papi"),
@@ -6888,6 +7990,8 @@ function loadConfig() {
 // src/adapter-factory.ts
 init_dist2();
 import path2 from "path";
+var HOSTED_PROXY_ENDPOINT = "https://guewgygcpcmrcoppihzx.supabase.co/functions/v1/data-proxy";
+var HOSTED_PROXY_KEY = "e9891a0a2225ac376f88ebdad78b4814b52ce0a39a41c5ec";
 var PLACEHOLDER_PATTERNS = [
   "<YOUR_DATABASE_URL>",
   "your-database-url",
@@ -6933,6 +8037,11 @@ async function createAdapter(optionsOrType, maybePapiDir) {
       }
       const config2 = papiEndpoint ? { connectionString: papiEndpoint } : configFromEnv2();
       validateDatabaseUrl(config2.connectionString);
+      try {
+        const { ensureSchema: ensureSchema2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
+        await ensureSchema2(config2);
+      } catch {
+      }
       try {
         const pgAdapter = new PgAdapter2(config2);
         const existing = await pgAdapter.getProject(projectId);
@@ -6960,10 +8069,36 @@ async function createAdapter(optionsOrType, maybePapiDir) {
       }
       return adapter2;
     }
+    case "proxy": {
+      const { ProxyPapiAdapter: ProxyPapiAdapter2 } = await Promise.resolve().then(() => (init_proxy_adapter(), proxy_adapter_exports));
+      const projectId = process.env["PAPI_PROJECT_ID"];
+      if (!projectId) {
+        throw new Error(
+          "PAPI_PROJECT_ID is required. Generate a UUID (run `uuidgen` in terminal) and set it in your .mcp.json env config."
+        );
+      }
+      const dataEndpoint = process.env["PAPI_DATA_ENDPOINT"] || HOSTED_PROXY_ENDPOINT;
+      const dataApiKey = process.env["PAPI_DATA_API_KEY"] || HOSTED_PROXY_KEY;
+      const adapter2 = new ProxyPapiAdapter2({
+        endpoint: dataEndpoint,
+        apiKey: dataApiKey,
+        projectId
+      });
+      const connected = await adapter2.probeConnection();
+      if (connected) {
+        _connectionStatus = "connected";
+        console.error("[papi] \u2713 Data proxy connected");
+      } else {
+        _connectionStatus = "degraded";
+        console.error("[papi] \u2717 Data proxy unreachable \u2014 running in degraded mode");
+        console.error("[papi] Check your PAPI_DATA_ENDPOINT configuration.");
+      }
+      return adapter2;
+    }
     default: {
       const _exhaustive = adapterType;
       throw new Error(
-        `Unknown PAPI_ADAPTER value: "${_exhaustive}". Valid options: "md", "pg".`
+        `Unknown PAPI_ADAPTER value: "${_exhaustive}". Valid options: "md", "pg", "proxy".`
       );
     }
   }
@@ -7981,6 +9116,7 @@ Standard planning sprint with full board review.
    - **Surprises:** If a surprise reveals a gap (e.g. "schema assumed but not verified"), propose a task to close it.
    - **Architecture Notes:** If a pattern was established that needs follow-up (e.g. "shared service layer created, MCP migration needed"), propose the follow-up.
    - **Strategy gaps:** If an Active Decision has no board tasks supporting it, propose one.
+   - **Dogfood observations:** If unactioned dogfood entries are listed in context (with IDs), check if any map to existing tasks. If not, propose a new task. Include \`dogfood:ID\` in the new task's notes so the pipeline can link them.
    Create new tasks via the \`newTasks\` array in Part 2. Use \`new-N\` IDs in \`cycleHandoffs\` to reference them. **Limit: 3 new tasks per sprint** to prevent backlog bloat.
    **\u26A0\uFE0F DUPLICATE CHECK:** Before adding a task to \`newTasks\`, scan the Sprint Board above for any existing task with the same or very similar title/scope. If a matching task already exists (even with slightly different wording), do NOT create a duplicate \u2014 reference the existing task ID instead. The board already contains all active tasks; re-creating them wastes IDs and bloats the board.
    **\u26A0\uFE0F ALREADY-BUILT CHECK:** Before creating a task, check the recent build reports and sprint log for evidence that this capability was already shipped. If a recent build report shows this feature was completed (even under a different task name), do NOT create a new task for it. This is especially important for UI features, data models, and integrations that may already exist.
@@ -8280,8 +9416,8 @@ After your natural language output, include this EXACT format on its own line:
   "activeDecisionUpdates": [
     {
       "id": "string \u2014 AD-N (existing) or new AD-N (for new decisions)",
-      "action": "confidence_change | modify | resolve | supersede | new",
-      "body": "string \u2014 full AD block including ### heading, confidence tag, and body text"
+      "action": "confidence_change | modify | resolve | supersede | new | delete",
+      "body": "string \u2014 full AD block including ### heading, confidence tag, and body text (empty string for delete)"
     }
   ],
   "decisionScores": [
@@ -8346,7 +9482,7 @@ Everything in Part 1 (natural language) is **display-only**. Part 2 (structured
 
 **If you analysed it in Part 1, it MUST appear in Part 2 to persist. Empty arrays/null = nothing saved.**
 
-- Recommended AD changes in Part 1? \u2192 Put them in \`activeDecisionUpdates\` with full body including ### heading
+- Recommended AD changes in Part 1? \u2192 Put them in \`activeDecisionUpdates\` with full body including ### heading. Use \`delete\` action (with empty body) to permanently remove non-strategic ADs (implementation details, resolved decisions, library choices). Use \`supersede\` when a decision is replaced by a new one.
 - Scored ADs in Part 1? \u2192 Put scores in \`decisionScores\` array with id, dimensions, and rationale
 - Identified proven insights, direction changes, or deprecated approaches? \u2192 Put the full updated product brief in \`productBriefUpdates\`. This is how strategic learnings get locked into the project's institutional memory. Common triggers: a phase completing, a hypothesis being validated/invalidated, a new constraint emerging, or the North Star evolving.${compressionPersistence}
 - Wrote a strategy review in Part 1? \u2192 \`sessionLogTitle\`, \`sessionLogContent\`, \`velocityAssessment\`, \`strategicRecommendations\` must all be populated
@@ -8480,8 +9616,8 @@ After your natural language output, include this EXACT format on its own line:
   "activeDecisionUpdates": [
     {
       "id": "string \u2014 AD-N (existing) or new AD-N (for new decisions)",
-      "action": "confidence_change | modify | resolve | supersede | new",
-      "body": "string \u2014 full AD block including ### heading, confidence tag, and body text"
+      "action": "confidence_change | modify | resolve | supersede | new | delete",
+      "body": "string \u2014 full AD block including ### heading, confidence tag, and body text (empty string for delete)"
     }
   ],
   "phaseUpdates": [
@@ -8794,6 +9930,60 @@ ${inputs.codebaseContext}
 Return a JSON array of 3-10 tasks based on gaps, improvements, and next steps visible from the codebase analysis above.`;
 }
 
+// src/lib/prompt-registry.ts
+var LOCAL_PROMPTS = {
+  "plan-system": PLAN_SYSTEM,
+  "plan-bootstrap": PLAN_BOOTSTRAP_INSTRUCTIONS,
+  "plan-full": PLAN_FULL_INSTRUCTIONS,
+  "review-system": buildReviewSystemPrompt(),
+  "strategy-change-system": STRATEGY_CHANGE_SYSTEM,
+  "handoff-regen-system": HANDOFF_REGEN_SYSTEM
+};
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+var cache = /* @__PURE__ */ new Map();
+function getEndpoint() {
+  return process.env.PAPI_PROMPT_ENDPOINT;
+}
+function getApiKey() {
+  return process.env.PAPI_PROMPT_API_KEY;
+}
+async function getPrompt(name) {
+  const endpoint = getEndpoint();
+  if (!endpoint) {
+    return LOCAL_PROMPTS[name];
+  }
+  const cached = cache.get(name);
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.content;
+  }
+  try {
+    const url = endpoint.endsWith("/") ? `${endpoint}${name}` : `${endpoint}/${name}`;
+    const apiKey = getApiKey();
+    const headers = {
+      "Accept": "application/json"
+    };
+    if (apiKey) {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(url, { headers, signal: AbortSignal.timeout(1e4) });
+    if (!response.ok) {
+      if (cached) return cached.content;
+      return LOCAL_PROMPTS[name];
+    }
+    const data = await response.json();
+    const content = data.content;
+    if (typeof content !== "string" || content.length === 0) {
+      if (cached) return cached.content;
+      return LOCAL_PROMPTS[name];
+    }
+    cache.set(name, { content, fetchedAt: Date.now() });
+    return content;
+  } catch {
+    if (cached) return cached.content;
+    return LOCAL_PROMPTS[name];
+  }
+}
+
 // src/services/plan.ts
 function determineMode(totalSprints) {
   if (totalSprints === 0) return "bootstrap";
@@ -9007,6 +10197,15 @@ function applyContextDiff(ctx, prevHashes) {
   return { ctx, newHashes, savedBytes };
 }
 async function readDogfoodEntries(projectRoot, count = 5, adapter2) {
+  if (adapter2?.getUnactionedDogfoodEntries) {
+    try {
+      const entries = await adapter2.getUnactionedDogfoodEntries(count);
+      if (entries.length > 0) {
+        return "**Unactioned observations (status: observed):**\n" + entries.map((e) => `- **[${e.category}]** (Cycle ${e.cycleNumber}, id: ${e.id}) ${e.content}`).join("\n");
+      }
+    } catch {
+    }
+  }
   if (adapter2?.getDogfoodLog) {
     try {
       const entries = await adapter2.getDogfoodLog(count);
@@ -9462,6 +10661,15 @@ ${cleanContent}`;
         notes: task.notes || ""
       });
       newTaskIdMap.set(`new-${i + 1}`, created.id);
+      if (adapter2.updateDogfoodEntryStatus && task.notes) {
+        const dogfoodRefs = task.notes.match(/dogfood:([a-f0-9-]+)/gi);
+        if (dogfoodRefs) {
+          for (const ref of dogfoodRefs) {
+            const entryId = ref.split(":")[1];
+            await adapter2.updateDogfoodEntryStatus(entryId, "backlog-created", created.id);
+          }
+        }
+      }
     }
   })();
   const priorityLockNotes = [];
@@ -9769,10 +10977,11 @@ async function preparePlan(adapter2, config2, filters, focus, force) {
     }
   } catch {
   }
+  const planSystemPrompt = await getPrompt("plan-system");
   return {
     mode,
     cycleNumber: sprintNumber,
-    systemPrompt: PLAN_SYSTEM,
+    systemPrompt: planSystemPrompt,
     userMessage,
     strategyReviewWarning,
     contextBytes,
@@ -10408,14 +11617,14 @@ async function assembleContext2(adapter2, sprintNumber, sprintsSinceLastReview,
     northStar: currentNorthStar ?? void 0,
     recommendationEffectiveness: recEffectivenessText
   };
-  const BUDGET_SOFT = 8e4;
-  const BUDGET_HARD = 1e5;
+  const BUDGET_SOFT2 = 8e4;
+  const BUDGET_HARD2 = 1e5;
   const compressionSteps = [];
   function measureContext(ctx) {
     return Object.values(ctx).filter((v) => typeof v === "string").reduce((sum, s) => sum + s.length, 0);
   }
   let contextSize = measureContext(context);
-  if (contextSize > BUDGET_SOFT && context.previousReviews) {
+  if (contextSize > BUDGET_SOFT2 && context.previousReviews) {
     const reviews2 = previousStrategyReviews;
     if (reviews2.length > 1) {
       const firstFull = formatPreviousReviews([reviews2[0]]) ?? "";
@@ -10429,7 +11638,7 @@ async function assembleContext2(adapter2, sprintNumber, sprintsSinceLastReview,
       compressionSteps.push(`Step 1: previous reviews capped (1 full + ${reviews2.length - 1} headers)`);
     }
   }
-  if (contextSize > BUDGET_SOFT && context.humanReviews) {
+  if (contextSize > BUDGET_SOFT2 && context.humanReviews) {
     const trimmed = formatReviews(reviews.slice(0, 5));
     if (trimmed.length < context.humanReviews.length) {
       context.humanReviews = trimmed;
@@ -10437,7 +11646,7 @@ async function assembleContext2(adapter2, sprintNumber, sprintsSinceLastReview,
       compressionSteps.push("Step 2: human reviews capped to 5");
     }
   }
-  if (contextSize > BUDGET_SOFT && context.allBuildReports) {
+  if (contextSize > BUDGET_SOFT2 && context.allBuildReports) {
     const summary = formatRecentReportsSummary(reports, 10);
     if (summary.length < context.allBuildReports.length) {
       context.allBuildReports = summary;
@@ -10445,11 +11654,11 @@ async function assembleContext2(adapter2, sprintNumber, sprintsSinceLastReview,
       compressionSteps.push("Step 3: build reports summarized");
     }
   }
-  if (contextSize > BUDGET_HARD) {
+  if (contextSize > BUDGET_HARD2) {
     const entries = Object.entries(context).filter((e) => typeof e[1] === "string").sort((a, b2) => b2[1].length - a[1].length);
     if (entries.length > 0) {
       const [key, value] = entries[0];
-      const excess = contextSize - BUDGET_SOFT;
+      const excess = contextSize - BUDGET_SOFT2;
       const newLength = Math.max(value.length - excess, 1e3);
       context[key] = value.slice(0, newLength) + "\n\n[truncated \u2014 context budget exceeded]";
       contextSize = measureContext(context);
@@ -10506,8 +11715,12 @@ ${cleanContent}`;
   }
   if (data.activeDecisionUpdates && data.activeDecisionUpdates.length > 0) {
     for (const ad of data.activeDecisionUpdates) {
-      await adapter2.updateActiveDecision(ad.id, ad.body, sprintNumber);
-      const eventType = ad.action === "confidence_change" ? "confidence_changed" : ad.action === "supersede" ? "superseded" : ad.action === "new" ? "created" : "modified";
+      if (ad.action === "delete" && adapter2.deleteActiveDecision) {
+        await adapter2.deleteActiveDecision(ad.id);
+      } else {
+        await adapter2.updateActiveDecision(ad.id, ad.body, sprintNumber);
+      }
+      const eventType = ad.action === "delete" ? "deleted" : ad.action === "confidence_change" ? "confidence_changed" : ad.action === "supersede" ? "superseded" : ad.action === "new" ? "created" : "modified";
       try {
         await adapter2.appendDecisionEvent({
           decisionId: ad.id,
@@ -10939,8 +12152,12 @@ ${cleanContent}`;
       });
       if (data.activeDecisionUpdates && data.activeDecisionUpdates.length > 0) {
         for (const ad of data.activeDecisionUpdates) {
-          await adapter2.updateActiveDecision(ad.id, ad.body, sprintNumber);
-          const eventType = ad.action === "confidence_change" ? "confidence_changed" : ad.action === "supersede" ? "superseded" : ad.action === "new" ? "created" : "modified";
+          if (ad.action === "delete" && adapter2.deleteActiveDecision) {
+            await adapter2.deleteActiveDecision(ad.id);
+          } else {
+            await adapter2.updateActiveDecision(ad.id, ad.body, sprintNumber);
+          }
+          const eventType = ad.action === "delete" ? "deleted" : ad.action === "confidence_change" ? "confidence_changed" : ad.action === "supersede" ? "superseded" : ad.action === "new" ? "created" : "modified";
           try {
             await adapter2.appendDecisionEvent({
               decisionId: ad.id,
@@ -11005,9 +12222,10 @@ async function prepareStrategyChange(adapter2, text) {
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`reading project state: ${message}`);
   }
+  const strategyChangePrompt = await getPrompt("strategy-change-system");
   return {
     sprintNumber,
-    systemPrompt: STRATEGY_CHANGE_SYSTEM,
+    systemPrompt: strategyChangePrompt,
     userMessage: buildStrategyChangeUserMessage(sprintNumber, text, productBrief, activeDecisions, phases, tasks, buildReports, previousReviewsText)
   };
 }
@@ -11426,25 +12644,34 @@ var boardViewTool = {
 };
 var boardDeprioritiseTool = {
   name: "board_deprioritise",
-  description: "Deprioritise a task \u2014 resets status to Backlog (preserving its BUILD HANDOFF) or Deferred if defer=true (clears handoff). Optionally sets a new priority or phase. Deferred tasks are excluded from plan context and default board views. Does not call the Anthropic API.",
+  description: `Remove a task from the current cycle. Three actions: "backlog" (not now, maybe later \u2014 preserves handoff), "defer" (valid but premature \u2014 hidden from planner), "cancel" (don't want this \u2014 permanently closed with reason). When a user rejects a task, ALWAYS ask which action they want. Does not call the Anthropic API.`,
   inputSchema: {
     type: "object",
     properties: {
       task_id: {
         type: "string",
-        description: "The task ID to deprioritise."
+        description: "The task ID to act on."
+      },
+      action: {
+        type: "string",
+        enum: ["backlog", "defer", "cancel"],
+        description: `"backlog" = not now, maybe later (preserves handoff). "defer" = valid but premature (hidden from planner). "cancel" = don't want this at all (permanently closed). If omitted, defaults to "backlog" for backwards compatibility.`
+      },
+      reason: {
+        type: "string",
+        description: 'Why this task is being removed. Required for "cancel", recommended for "defer".'
       },
       defer: {
         type: "boolean",
-        description: "If true, sets status to Deferred instead of Backlog. Deferred tasks are invisible to plan and default board_view."
+        description: 'DEPRECATED \u2014 use action instead. If true, equivalent to action="defer".'
       },
       priority: {
         type: "string",
-        description: 'Optional new priority for the deprioritised task (e.g. "P3 Low").'
+        description: 'Optional new priority (only applies to "backlog" action).'
       },
       phase: {
         type: "string",
-        description: "Optional new phase for the deprioritised task."
+        description: 'Optional new phase (only applies to "backlog" and "defer" actions).'
       }
     },
     required: ["task_id"]
@@ -11543,19 +12770,43 @@ async function handleBoardDeprioritise(adapter2, args) {
   if (!taskId) {
     return errorResponse("task_id is required for deprioritise.");
   }
-  const defer = args.defer;
+  const explicitAction = args.action;
+  const legacyDefer = args.defer;
+  const action = explicitAction ?? (legacyDefer ? "defer" : "backlog");
+  const reason = args.reason;
   const newPriority = args.priority;
   const newPhase = args.phase;
+  if (action === "cancel") {
+    if (!reason) {
+      return errorResponse("reason is required when cancelling a task.");
+    }
+    try {
+      const task = await adapter2.getTask(taskId);
+      if (!task) return errorResponse(`Task ${taskId} not found.`);
+      await adapter2.updateTask(taskId, {
+        status: "Cancelled",
+        buildHandoff: void 0,
+        closureReason: reason
+      });
+      return textResponse(`Cancelled **${taskId}** (${task.title}).
+
+Reason: ${reason}`);
+    } catch (err) {
+      return errorResponse(err instanceof Error ? err.message : String(err));
+    }
+  }
   try {
     const { task, changes } = await deprioritiseTask(adapter2, taskId, {
-      defer,
+      defer: action === "defer",
       priority: newPriority,
       phase: newPhase
     });
-    const action = defer ? "Deferred" : "Deprioritised";
-    return textResponse(`${action} **${taskId}** (${task.title}).
+    const label = action === "defer" ? "Deferred" : "Moved to Backlog";
+    const reasonNote = reason ? `
+Reason: ${reason}` : "";
+    return textResponse(`${label} **${taskId}** (${task.title}).
 
-Changes: ${changes.join(", ")}.`);
+Changes: ${changes.join(", ")}.${reasonNote}`);
   } catch (err) {
     return errorResponse(err instanceof Error ? err.message : String(err));
   }
@@ -11946,51 +13197,62 @@ function substitute(template, vars) {
   return result;
 }
 async function scaffoldPapiDir(adapter2, config2, input) {
-  if (config2.adapterType === "pg") {
-    return false;
-  }
-  try {
-    await access2(config2.papiDir);
-    return false;
-  } catch {
-    await mkdir(config2.papiDir, { recursive: true });
-    const vars = { project_name: input.projectName, description: input.description };
-    for (const [filename, template] of Object.entries(FILE_TEMPLATES)) {
-      const content = substitute(template, vars);
-      await writeFile2(join2(config2.papiDir, filename), content, "utf-8");
-    }
-    const commandsDir = join2(config2.projectRoot, ".claude", "commands");
-    const docsDir = join2(config2.projectRoot, "docs");
-    await mkdir(commandsDir, { recursive: true });
-    await mkdir(docsDir, { recursive: true });
-    const claudeMdPath = join2(config2.projectRoot, "CLAUDE.md");
-    let claudeMdExists = false;
+  const vars = { project_name: input.projectName, description: input.description };
+  const isPg = config2.adapterType === "pg";
+  if (!isPg) {
     try {
-      await access2(claudeMdPath);
-      claudeMdExists = true;
+      await access2(config2.papiDir);
+      return false;
     } catch {
+      await mkdir(config2.papiDir, { recursive: true });
+      for (const [filename, template] of Object.entries(FILE_TEMPLATES)) {
+        const content = substitute(template, vars);
+        await writeFile2(join2(config2.papiDir, filename), content, "utf-8");
+      }
     }
-    const docsIndexPath = join2(docsDir, "INDEX.md");
-    let docsIndexExists = false;
+  }
+  const commandsDir = join2(config2.projectRoot, ".claude", "commands");
+  const docsDir = join2(config2.projectRoot, "docs");
+  await mkdir(commandsDir, { recursive: true });
+  await mkdir(docsDir, { recursive: true });
+  const claudeMdPath = join2(config2.projectRoot, "CLAUDE.md");
+  let claudeMdExists = false;
+  try {
+    await access2(claudeMdPath);
+    claudeMdExists = true;
+  } catch {
+  }
+  const docsIndexPath = join2(docsDir, "INDEX.md");
+  let docsIndexExists = false;
+  try {
+    await access2(docsIndexPath);
+    docsIndexExists = true;
+  } catch {
+  }
+  const scaffoldFiles = {
+    [join2(commandsDir, "papi-audit.md")]: PAPI_AUDIT_COMMAND_TEMPLATE,
+    [join2(commandsDir, "test.md")]: TEST_COMMAND_TEMPLATE,
+    [join2(docsDir, "README.md")]: substitute(DOCS_README_TEMPLATE, vars)
+  };
+  if (!docsIndexExists) {
+    scaffoldFiles[docsIndexPath] = substitute(DOCS_INDEX_TEMPLATE, vars);
+  }
+  if (!claudeMdExists) {
+    scaffoldFiles[claudeMdPath] = substitute(CLAUDE_MD_TEMPLATE, vars);
+  } else {
     try {
-      await access2(docsIndexPath);
-      docsIndexExists = true;
+      const existing = await readFile3(claudeMdPath, "utf-8");
+      if (!existing.includes("## Workflow Sequences") && !existing.includes("### The Cycle (main flow)")) {
+        const papiSection = "\n\n" + substitute(CLAUDE_MD_TEMPLATE, vars).split("\n").slice(1).join("\n");
+        scaffoldFiles[claudeMdPath] = existing + papiSection;
+      }
     } catch {
     }
-    const scaffoldFiles = {
-      [join2(commandsDir, "papi-audit.md")]: PAPI_AUDIT_COMMAND_TEMPLATE,
-      [join2(commandsDir, "test.md")]: TEST_COMMAND_TEMPLATE,
-      [join2(docsDir, "README.md")]: substitute(DOCS_README_TEMPLATE, vars)
-    };
-    if (!docsIndexExists) {
-      scaffoldFiles[docsIndexPath] = substitute(DOCS_INDEX_TEMPLATE, vars);
-    }
-    if (!claudeMdExists) {
-      scaffoldFiles[claudeMdPath] = substitute(CLAUDE_MD_TEMPLATE, vars);
-    }
-    for (const [filepath, content] of Object.entries(scaffoldFiles)) {
-      await writeFile2(filepath, content, "utf-8");
-    }
+  }
+  for (const [filepath, content] of Object.entries(scaffoldFiles)) {
+    await writeFile2(filepath, content, "utf-8");
+  }
+  if (!isPg) {
     await adapter2.writePhases([{
       id: "phase-0",
       slug: "setup",
@@ -11999,9 +13261,9 @@ async function scaffoldPapiDir(adapter2, config2, input) {
       status: "In Progress",
       order: 0
     }]);
-    await ensurePapiPermission(config2.projectRoot);
-    return true;
   }
+  await ensurePapiPermission(config2.projectRoot);
+  return true;
 }
 var PAPI_PERMISSION = "mcp__papi__*";
 async function ensurePapiPermission(projectRoot) {
@@ -12745,7 +14007,7 @@ async function describeTask(adapter2, taskId) {
   }
   return { task };
 }
-async function startBuild(adapter2, config2, taskId) {
+async function startBuild(adapter2, config2, taskId, options = {}) {
   const task = await adapter2.getTask(taskId);
   if (!task) {
     throw new Error(`Task "${taskId}" not found on the Sprint Board.`);
@@ -12772,7 +14034,9 @@ async function startBuild(adapter2, config2, taskId) {
     throw err;
   }
   const branchLines = [];
-  if (config2.autoCommit && isGitAvailable() && isGitRepo(config2.projectRoot)) {
+  if (options.light) {
+    branchLines.push("Light mode: skipping branch creation \u2014 working on current branch.");
+  } else if (config2.autoCommit && isGitAvailable() && isGitRepo(config2.projectRoot)) {
     const featureBranch = taskBranchName(taskId);
     const currentBranch = getCurrentBranch(config2.projectRoot);
     if (currentBranch === featureBranch) {
@@ -12806,11 +14070,21 @@ async function startBuild(adapter2, config2, taskId) {
         branchLines.push(
           checkout.success ? `Checked out existing branch '${featureBranch}'.` : `Warning: ${checkout.message}`
         );
+        if (checkout.success) {
+          branchLines.push(
+            'Note: IDE may report files as "modified by linter" after branch switch \u2014 this is normal git checkout behaviour, not reverted changes. Ignore these notifications.'
+          );
+        }
       } else {
         const create = createAndCheckoutBranch(config2.projectRoot, featureBranch);
         branchLines.push(
           create.success ? `Created branch '${featureBranch}'.` : `Warning: ${create.message}`
         );
+        if (create.success) {
+          branchLines.push(
+            'Note: IDE may report files as "modified by linter" after branch switch \u2014 this is normal git checkout behaviour, not reverted changes. Ignore these notifications.'
+          );
+        }
       }
     }
   }
@@ -12824,7 +14098,7 @@ async function startBuild(adapter2, config2, taskId) {
   }
   return { task, branchLines, phaseChanges };
 }
-async function completeBuild(adapter2, config2, taskId, input) {
+async function completeBuild(adapter2, config2, taskId, input, options = {}) {
   const task = await adapter2.getTask(taskId);
   if (!task) {
     throw new Error(`Task "${taskId}" not found on the Sprint Board.`);
@@ -12884,9 +14158,13 @@ async function completeBuild(adapter2, config2, taskId, input) {
   const buildReportSummary = `${capitalizeCompleted(input.completed)}. Effort ${input.effort} vs estimated ${input.estimatedEffort}.${surpriseNote}${issueNote}`;
   await adapter2.updateTask(taskId, { buildReport: buildReportSummary });
   if (input.completed === "yes") {
-    await adapter2.updateTaskStatus(taskId, "In Review");
+    if (options.light) {
+      await adapter2.updateTaskStatus(taskId, "Done");
+    } else {
+      await adapter2.updateTaskStatus(taskId, "In Review");
+    }
   }
-  const statusNote = input.completed === "yes" ? `Task "${task.title}" (${taskId}) marked In Review \u2014 ready for your sign-off via \`review_submit\`.` : `Task "${task.title}" (${taskId}) status unchanged (completed: ${input.completed}).`;
+  const statusNote = input.completed === "yes" ? options.light ? `Task "${task.title}" (${taskId}) marked Done (light mode \u2014 no review needed).` : `Task "${task.title}" (${taskId}) marked In Review \u2014 ready for your sign-off via \`review_submit\`.` : `Task "${task.title}" (${taskId}) status unchanged (completed: ${input.completed}).`;
   let commitLine;
   if (config2.autoCommit) {
     commitLine = autoCommit(config2, taskId, task.title);
@@ -12901,7 +14179,9 @@ async function completeBuild(adapter2, config2, taskId, input) {
     if (changed.length > 0) report.filesChanged = changed;
   }
   let prLines = [];
-  if (config2.autoCommit && input.completed === "yes") {
+  if (options.light) {
+    prLines.push("Light mode: skipping push and PR creation.");
+  } else if (config2.autoCommit && input.completed === "yes") {
     prLines = pushAndCreatePR(config2, taskId, task.title);
   }
   const allTasks = await adapter2.queryBoard();
@@ -12976,6 +14256,10 @@ var buildExecuteTool = {
         type: "string",
         description: "The task ID to execute."
       },
+      light: {
+        type: "boolean",
+        description: "Light-ceremony mode for XS/S tasks. Skips feature branch creation and PR. Work stays on current branch. Build report is still captured. Default false."
+      },
       completed: {
         type: "string",
         enum: ["yes", "no", "partial"],
@@ -13130,11 +14414,12 @@ async function handleBuildExecute(adapter2, config2, args) {
   if (!taskId) {
     return errorResponse("task_id is required.");
   }
+  const light = args.light === true;
   if (hasReportFields(args)) {
-    return handleExecuteComplete(adapter2, config2, taskId, args);
+    return handleExecuteComplete(adapter2, config2, taskId, args, light);
   }
   try {
-    const result = await startBuild(adapter2, config2, taskId);
+    const result = await startBuild(adapter2, config2, taskId, { light });
     const branchInfo = result.branchLines.length > 0 ? result.branchLines.map((l) => `> ${l}`).join("\n") + "\n\n" : "";
     const phaseNote = result.phaseChanges.length > 0 ? "\n\n" + result.phaseChanges.map((c) => `Phase auto-updated: ${c.phaseId} ${c.oldStatus} \u2192 ${c.newStatus}`).join("\n") : "";
     const header = `${branchInfo}**Executing ${result.task.id}: ${result.task.title}** \u2014 marked In Progress.
@@ -13167,7 +14452,7 @@ async function handleBuildExecute(adapter2, config2, args) {
     return errorResponse(err instanceof Error ? err.message : String(err));
   }
 }
-async function handleExecuteComplete(adapter2, config2, taskId, args) {
+async function handleExecuteComplete(adapter2, config2, taskId, args, light = false) {
   const completed = args.completed;
   const effort = args.effort;
   const estimatedEffort = args.estimated_effort;
@@ -13214,7 +14499,7 @@ async function handleExecuteComplete(adapter2, config2, taskId, args) {
         type: bi.type ?? "new",
         detail: bi.detail ?? ""
       }))
-    });
+    }, { light });
     return textResponse(formatCompleteResult(result));
   } catch (err) {
     return errorResponse(err instanceof Error ? err.message : String(err));
@@ -13366,6 +14651,131 @@ function resolveCurrentPhase(phases) {
   const sorted = [...phases].sort((a, b2) => a.order - b2.order);
   return sorted[0].label;
 }
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "has",
+  "have",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "can",
+  "not",
+  "no",
+  "if",
+  "then",
+  "than",
+  "that",
+  "this",
+  "it",
+  "its",
+  "all",
+  "each",
+  "every",
+  "both",
+  "as",
+  "so",
+  "up",
+  "out",
+  "about",
+  "into",
+  "over",
+  "after",
+  "before",
+  "between",
+  "under",
+  "above",
+  "such",
+  "only",
+  "also",
+  "just",
+  "more",
+  "most",
+  "other",
+  "some",
+  "any",
+  "new",
+  "when",
+  "how",
+  "what",
+  "which",
+  "who",
+  "add",
+  "create",
+  "build",
+  "implement",
+  "make",
+  "update",
+  "fix",
+  "use",
+  "via",
+  "show",
+  "display",
+  "view",
+  "page",
+  "data",
+  "based",
+  "using"
+]);
+function extractKeywords(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w))
+  );
+}
+async function findSimilarTasks(adapter2, ideaTitle) {
+  const ideaKeywords = extractKeywords(ideaTitle);
+  if (ideaKeywords.size < 2) return [];
+  const [backlog, done] = await Promise.all([
+    adapter2.queryBoard({ status: ["Backlog", "In Cycle", "In Progress", "In Review"] }),
+    adapter2.queryBoard({ status: ["Done"] })
+  ]);
+  const allTasks = [...backlog, ...done];
+  const matches = [];
+  for (const task of allTasks) {
+    const taskKeywords = extractKeywords(task.title);
+    if (taskKeywords.size < 2) continue;
+    let covered = 0;
+    for (const word of ideaKeywords) {
+      if (taskKeywords.has(word)) covered++;
+    }
+    const coverage = covered / ideaKeywords.size;
+    if (coverage >= 0.4) {
+      matches.push({
+        id: task.id,
+        title: task.title,
+        status: task.status,
+        coverage
+      });
+    }
+  }
+  return matches.sort((a, b2) => b2.coverage - a.coverage).slice(0, 3);
+}
 async function captureIdea(adapter2, input) {
   if (input.discovery) {
     const routing = classifyIdea(input.text, input.notes);
@@ -13373,6 +14783,37 @@ async function captureIdea(adapter2, input) {
       return routeToDiscovery(adapter2, routing, input);
     }
   }
+  let similarWarning = "";
+  try {
+    const similar = await findSimilarTasks(adapter2, input.text);
+    if (similar.length > 0) {
+      const highOverlap = similar.filter((s) => s.coverage >= 0.7);
+      if (highOverlap.length > 0 && !input.force) {
+        const lines = highOverlap.map(
+          (s) => `  - **${s.id}** [${s.status}]: "${s.title}" (${Math.round(s.coverage * 100)}% keyword overlap)`
+        );
+        const doneMatch = highOverlap.find((s) => s.status === "Done");
+        const reason = doneMatch ? `This looks like it was **already done** as ${doneMatch.id}.` : `This looks like a **duplicate** of ${highOverlap[0].id}.`;
+        return {
+          routing: "task",
+          message: `\u26D4 **Blocked \u2014 ${reason}**
+
+High-overlap tasks:
+${lines.join("\n")}
+
+If this is genuinely different, re-run with \`force: true\`.`
+        };
+      }
+      const warnLines = similar.map(
+        (s) => `  - **${s.id}** [${s.status}]: "${s.title}" (${Math.round(s.coverage * 100)}% keyword overlap)`
+      );
+      similarWarning = `
+
+\u26A0\uFE0F **Similar tasks found** \u2014 check before scheduling:
+${warnLines.join("\n")}`;
+    }
+  } catch {
+  }
   const [health, phases] = await Promise.all([
     adapter2.getSprintHealth(),
     adapter2.readPhases()
@@ -13396,7 +14837,7 @@ async function captureIdea(adapter2, input) {
     taskType: "idea",
     maturity: "raw"
   });
-  return { routing: "task", task, message: `${task.id}: "${task.title}" \u2014 added to backlog` };
+  return { routing: "task", task, message: `${task.id}: "${task.title}" \u2014 added to backlog${similarWarning}` };
 }
 var CANVAS_SECTION_LABELS = {
   landscape: "Landscape References",
@@ -13463,6 +14904,10 @@ var ideaTool = {
       discovery: {
         type: "boolean",
         description: "When true, classify the idea and route to Discovery Canvas instead of backlog. Default: false (always creates a backlog task)."
+      },
+      force: {
+        type: "boolean",
+        description: "Force creation even if a high-overlap duplicate or already-done task is detected. Default: false."
       }
     },
     required: ["text"]
@@ -13486,7 +14931,8 @@ async function handleIdea(adapter2, config2, args) {
     epic: args.epic,
     phase: args.phase,
     notes: rawNotes,
-    discovery: args.discovery === true
+    discovery: args.discovery === true,
+    force: args.force === true
   };
   const useGit = isGitAvailable() && isGitRepo(config2.projectRoot);
   const currentBranch = useGit ? getCurrentBranch(config2.projectRoot) : null;
@@ -13860,6 +15306,40 @@ async function prepareReconcile(adapter2) {
     }
     lines.push("");
   }
+  const doneTasks = await adapter2.queryBoard({ status: ["Done"] });
+  const doneOverlaps = [];
+  for (const bt of allTasks) {
+    const bWords = titleKeywords(bt.title);
+    if (bWords.size < 3) continue;
+    for (const dt of doneTasks) {
+      const dWords = titleKeywords(dt.title);
+      if (dWords.size < 3) continue;
+      let covered = 0;
+      for (const w of bWords) {
+        if (dWords.has(w)) covered++;
+      }
+      const coverage = covered / Math.min(bWords.size, dWords.size);
+      if (coverage >= 0.6) {
+        doneOverlaps.push({ backlog: bt, done: dt, coverage });
+      }
+    }
+  }
+  if (doneOverlaps.length > 0) {
+    const bestMatches = /* @__PURE__ */ new Map();
+    for (const { backlog, done, coverage } of doneOverlaps) {
+      const existing = bestMatches.get(backlog.id);
+      if (!existing || coverage > existing.coverage) {
+        bestMatches.set(backlog.id, { done, coverage });
+      }
+    }
+    lines.push("### Already Done? (backlog tasks overlapping with completed work)");
+    lines.push("These backlog tasks may duplicate work already shipped. **Cancel unless the scope is genuinely different.**");
+    for (const [backlogId, { done, coverage }] of bestMatches) {
+      const bt = allTasks.find((t) => t.id === backlogId);
+      lines.push(`- **${bt.id}** "${bt.title.slice(0, 60)}" \u2190 already done as **${done.id}** "${done.title.slice(0, 60)}" (${Math.round(coverage * 100)}% overlap)`);
+    }
+    lines.push("");
+  }
   lines.push("### All Backlog Tasks by Module");
   lines.push("");
   for (const [mod, tasks] of byModule) {
@@ -13873,11 +15353,16 @@ async function prepareReconcile(adapter2) {
   }
   return lines.join("\n");
 }
+var STOP_WORDS2 = /* @__PURE__ */ new Set(["the", "a", "an", "and", "or", "for", "in", "on", "to", "of", "is", "with", "from", "by", "vs", "not", "no", "do"]);
+function tokenize(s) {
+  return s.toLowerCase().replace(/[^a-z0-9\s-]/g, "").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS2.has(w));
+}
+function titleKeywords(title) {
+  return new Set(tokenize(title));
+}
 function titleKeywordOverlap(a, b2) {
-  const STOP_WORDS = /* @__PURE__ */ new Set(["the", "a", "an", "and", "or", "for", "in", "on", "to", "of", "is", "with", "from", "by", "vs", "not", "no", "do"]);
-  const tokenize = (s) => s.toLowerCase().replace(/[^a-z0-9\s-]/g, "").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w));
-  const wordsA = new Set(tokenize(a));
-  const wordsB = new Set(tokenize(b2));
+  const wordsA = titleKeywords(a);
+  const wordsB = titleKeywords(b2);
   return [...wordsA].filter((w) => wordsB.has(w)).length;
 }
 async function applyReconcile(adapter2, corrections) {
@@ -13938,7 +15423,17 @@ async function applyReconcile(adapter2, corrections) {
       skipped++;
     }
   }
-  return { applied, skipped, details };
+  let phaseChanges = [];
+  if (applied > 0) {
+    try {
+      phaseChanges = await propagatePhaseStatus(adapter2);
+      for (const c of phaseChanges) {
+        details.push(`Phase "${c.phaseId}": ${c.oldStatus} \u2192 ${c.newStatus}`);
+      }
+    } catch {
+    }
+  }
+  return { applied, skipped, details, phaseChanges };
 }
 
 // src/tools/board-reconcile.ts
@@ -14555,9 +16050,10 @@ async function listPendingReviews(adapter2) {
   const pendingBuilds = tasks.filter((t) => t.status === "In Review");
   return { pendingBuilds };
 }
-function prepareHandoffRegen(task, reviewerComments) {
+async function prepareHandoffRegen(task, reviewerComments) {
+  const systemPrompt = await getPrompt("handoff-regen-system");
   return {
-    systemPrompt: HANDOFF_REGEN_SYSTEM,
+    systemPrompt,
     userMessage: buildHandoffRegenMessage({
       existingHandoff: task.buildHandoff ? serializeBuildHandoff(task.buildHandoff) : "",
       reviewerComments,
@@ -14610,6 +16106,9 @@ async function submitReview(adapter2, input) {
       review.buildCommitSha = taskReport.commitSha;
     }
   }
+  if (input.autoReview) {
+    review.autoReview = input.autoReview;
+  }
   await adapter2.writeReview(review);
   const newStatus = resolveStatus(input.stage, input.verdict);
   if (newStatus) {
@@ -14635,7 +16134,7 @@ async function submitReview(adapter2, input) {
   const handoffRegenerated = false;
   let handoffRegenPrompt;
   if (input.stage === "handoff-review" && input.verdict === "request-changes" && task.buildHandoff) {
-    handoffRegenPrompt = prepareHandoffRegen(task, input.comments);
+    handoffRegenPrompt = await prepareHandoffRegen(task, input.comments);
   }
   const stageLabel = input.stage === "handoff-review" ? "Handoff Review" : "Build Acceptance";
   const slackWarning = void 0;
@@ -14706,6 +16205,29 @@ var reviewSubmitTool = {
       notify: {
         type: "boolean",
         description: "Send Slack notification. Default true. Set false for batch middle reviews to avoid spam."
+      },
+      auto_review: {
+        type: "object",
+        description: "Optional automated code review results to attach to this review. Run PR analysis first, then pass findings here.",
+        properties: {
+          verdict: { type: "string", enum: ["pass", "warn", "fail"], description: "Auto-review verdict." },
+          summary: { type: "string", description: "One-line summary of auto-review findings." },
+          findings: {
+            type: "array",
+            description: "Structured findings from automated review.",
+            items: {
+              type: "object",
+              properties: {
+                severity: { type: "string", enum: ["error", "warning", "info"] },
+                file: { type: "string", description: "File path (optional)." },
+                line: { type: "integer", description: "Line number (optional)." },
+                message: { type: "string", description: "Finding description." }
+              },
+              required: ["severity", "message"]
+            }
+          }
+        },
+        required: ["verdict", "summary", "findings"]
       }
     },
     required: ["task_id", "stage", "verdict", "comments"]
@@ -14784,6 +16306,20 @@ async function handleReviewSubmit(adapter2, config2, args) {
   const comments = args.comments;
   const reviewer = args.reviewer ?? "human";
   const notify = args.notify !== false;
+  const rawAutoReview = args.auto_review;
+  let autoReview;
+  if (rawAutoReview?.verdict && rawAutoReview?.summary && Array.isArray(rawAutoReview?.findings)) {
+    autoReview = {
+      verdict: rawAutoReview.verdict,
+      summary: rawAutoReview.summary,
+      findings: rawAutoReview.findings.map((f) => ({
+        severity: f.severity ?? "info",
+        ...f.file ? { file: f.file } : {},
+        ...f.line ? { line: f.line } : {},
+        message: f.message ?? ""
+      }))
+    };
+  }
   if (!taskId) {
     return errorResponse("task_id is required.");
   }
@@ -14812,7 +16348,7 @@ async function handleReviewSubmit(adapter2, config2, args) {
   try {
     const result = await submitReview(
       adapter2,
-      { taskId, stage, verdict, comments, reviewer, notify }
+      { taskId, stage, verdict, comments, reviewer, notify, autoReview }
     );
     const statusNote = result.newStatus ? ` Task status updated to **${result.newStatus}**.` : " Task status unchanged.";
     const unblockNote = result.unblockedTasks.length > 0 ? `
@@ -14879,13 +16415,16 @@ Run \`plan\` to create Cycle ${result.currentSprint + 1}.`;
       }
     }
     const phaseNote = result.phaseChanges.length > 0 ? "\n\n" + result.phaseChanges.map((c) => `Phase auto-updated: ${c.phaseId} ${c.oldStatus} \u2192 ${c.newStatus}`).join("\n") : "";
+    const autoReviewNote = autoReview ? `
+
+**Auto-Review:** ${autoReview.verdict} \u2014 ${autoReview.summary}` + (autoReview.findings.length > 0 ? ` (${autoReview.findings.length} finding${autoReview.findings.length === 1 ? "" : "s"})` : "") : "";
     return textResponse(
       `**${result.stageLabel}** recorded for ${result.taskId}.
 
 - **Verdict:** ${result.verdict}
 - **Comments:** ${result.comments}
 
-${statusNote}${unblockNote}${regenNote}${mergeNote}${slackNote}${autoReleaseNote}${phaseNote}`
+${statusNote}${autoReviewNote}${unblockNote}${regenNote}${mergeNote}${slackNote}${autoReleaseNote}${phaseNote}`
     );
   } catch (err) {
     return errorResponse(err instanceof Error ? err.message : String(err));
@@ -15275,6 +16814,20 @@ async function handleHierarchyUpdate(adapter2, args) {
 }
 
 // src/services/zoom-out.ts
+var BUDGET_SOFT = 12e4;
+var BUDGET_HARD = 15e4;
+function measureSections(secs) {
+  return secs.reduce((sum, s) => sum + s.length, 0);
+}
+function summariseBuildReports(reports, count) {
+  const recent = reports.slice(0, count);
+  if (recent.length === 0) return "No recent build reports.";
+  return recent.map((r) => {
+    const effort = `${r.actualEffort} vs ${r.estimatedEffort}`;
+    const surprises = r.surprises && r.surprises !== "None" ? ` \u2014 ${r.surprises.slice(0, 80)}${r.surprises.length > 80 ? "..." : ""}` : "";
+    return `- S${r.sprint} ${r.taskName}: ${effort}${surprises}`;
+  }).join("\n");
+}
 async function assembleZoomOutContext(adapter2, sprintNumber, projectRoot) {
   const [
     productBrief,
@@ -15288,12 +16841,15 @@ async function assembleZoomOutContext(adapter2, sprintNumber, projectRoot) {
   ] = await Promise.all([
     adapter2.readProductBrief(),
     adapter2.getActiveDecisions(),
-    adapter2.getRecentBuildReports(100),
-    adapter2.getSprintLog(50),
+    adapter2.getRecentBuildReports(50),
+    // Cap: 50 (was 100)
+    adapter2.getSprintLog(30),
+    // Cap: 30 (was 50)
     adapter2.queryBoard({
       status: ["Backlog", "In Cycle", "In Progress", "In Review", "Blocked", "Deferred"]
     }),
-    adapter2.getStrategyReviews(10, true),
+    adapter2.getStrategyReviews(5, true),
+    // Cap: 5 (was 10)
     readDogfoodEntries(projectRoot, 20, adapter2),
     adapter2.getCurrentNorthStar?.() ?? Promise.resolve(null)
   ]);
@@ -15333,7 +16889,8 @@ async function assembleZoomOutContext(adapter2, sprintNumber, projectRoot) {
   }
   let adLifecycleText = "";
   try {
-    const events = await adapter2.getDecisionEventsSince(1);
+    const sinceSprintNumber = Math.max(1, sprintNumber - 20);
+    const events = await adapter2.getDecisionEventsSince(sinceSprintNumber);
     if (events.length > 0) {
       const byDecision = /* @__PURE__ */ new Map();
       for (const e of events) {
@@ -15351,14 +16908,30 @@ async function assembleZoomOutContext(adapter2, sprintNumber, projectRoot) {
   }
   let reviewsText = "";
   if (strategyReviews.length > 0) {
-    const lines = strategyReviews.map((r) => {
+    const fullReviews = strategyReviews.slice(0, 3).map((r) => {
       const summary = r.fullAnalysis ? r.fullAnalysis.slice(0, 500) + (r.fullAnalysis.length > 500 ? "..." : "") : r.content;
       return `### Cycle ${r.sprintNumber}${r.sprintRange ? ` (${r.sprintRange})` : ""}
 ${summary}`;
     });
-    reviewsText = lines.join("\n\n");
+    const headerReviews = strategyReviews.slice(3).map((r) => {
+      const range = r.sprintRange ? `Cycles ${r.sprintRange}` : `Cycle ${r.sprintNumber}`;
+      return `#### ${range} \u2014 ${r.title}
+**Direction:** ${r.strategicDirection ?? "N/A"}`;
+    });
+    reviewsText = [...fullReviews, ...headerReviews].join("\n\n");
+  }
+  let doneTasksSummary = "";
+  try {
+    const doneTasks = await adapter2.queryBoard({ status: ["Done", "Cancelled"] });
+    if (doneTasks.length > 0) {
+      const doneCount = doneTasks.filter((t) => t.status === "Done").length;
+      const cancelledCount = doneTasks.filter((t) => t.status === "Cancelled").length;
+      doneTasksSummary = `**Completed:** ${doneCount} Done, ${cancelledCount} Cancelled`;
+    }
+  } catch {
   }
   const sections = [];
+  const compressionSteps = [];
   sections.push(`## Project State \u2014 Cycle ${sprintNumber}`);
   if (northStar) sections.push(`**North Star:** ${northStar}`);
   if (productBrief) {
@@ -15371,54 +16944,101 @@ ${summary}`;
     sections.push("## Active Decisions\n" + formatActiveDecisionsForReview(decisions));
   }
   if (adLifecycleText) {
-    sections.push("## AD Lifecycle Events (full history)\n" + adLifecycleText);
+    sections.push(`## AD Lifecycle Events (last 20 cycles)
+${adLifecycleText}`);
   }
   if (reviewsText) {
     sections.push("## Strategy Review History\n" + reviewsText);
   }
   if (log.length > 0) {
-    sections.push("## Sprint Log (recent 50)\n" + formatSprintLog(log));
+    sections.push("## Sprint Log (recent 30)\n" + formatSprintLog(log));
   }
-  if (reports.length > 0) {
-    sections.push("## Build Reports (recent 100)\n" + formatBuildReports(reports));
+  let buildReportsText = reports.length > 0 ? formatBuildReports(reports) : "";
+  if (buildReportsText) {
+    sections.push("## Build Reports (recent 50)\n" + buildReportsText);
   }
   if (activeTasks.length > 0) {
     sections.push("## Current Board\n" + formatBoardForReview(activeTasks));
   }
+  if (doneTasksSummary) {
+    sections.push("## Historical Task Counts\n" + doneTasksSummary);
+  }
   if (metricsText) {
     sections.push("## Velocity & Estimation Trends\n" + metricsText);
   }
   if (dogfoodLog) {
     sections.push("## Dogfood Log (recent 20)\n" + dogfoodLog);
   }
+  let contextSize = measureSections(sections);
+  if (contextSize > BUDGET_SOFT && buildReportsText) {
+    const summaryText = summariseBuildReports(reports, 30);
+    const idx = sections.findIndex((s) => s.startsWith("## Build Reports"));
+    if (idx >= 0) {
+      sections[idx] = "## Build Reports (summarised, recent 30)\n" + summaryText;
+      contextSize = measureSections(sections);
+      compressionSteps.push("Step 1: build reports summarised");
+    }
+  }
+  if (contextSize > BUDGET_SOFT) {
+    const logIdx = sections.findIndex((s) => s.startsWith("## Sprint Log"));
+    if (logIdx >= 0 && log.length > 15) {
+      sections[logIdx] = "## Sprint Log (recent 15)\n" + formatSprintLog(log.slice(0, 15));
+      contextSize = measureSections(sections);
+      compressionSteps.push("Step 2: sprint log trimmed to 15");
+    }
+  }
+  if (contextSize > BUDGET_HARD) {
+    const longest = sections.map((s, i) => ({ i, len: s.length })).sort((a, b2) => b2.len - a.len)[0];
+    if (longest) {
+      const excess = contextSize - BUDGET_SOFT;
+      const newLen = Math.max(longest.len - excess, 1e3);
+      sections[longest.i] = sections[longest.i].slice(0, newLen) + "\n\n[truncated \u2014 context budget exceeded]";
+      contextSize = measureSections(sections);
+      compressionSteps.push(`Step 3: truncated section ${longest.i} (was ${longest.len} chars)`);
+    }
+  }
+  const estimatedTokens = Math.ceil(contextSize / 4);
+  if (compressionSteps.length > 0) {
+    console.error(`[zoom_out] Context compressed: ${compressionSteps.join(" \u2192 ")}`);
+  }
+  console.error(`[zoom_out] Context size: ${contextSize.toLocaleString()} chars (~${estimatedTokens.toLocaleString()} tokens)`);
   return sections.join("\n\n");
 }
-var ZOOM_OUT_SYSTEM_PROMPT = `You are the PAPI Zoom-Out Analyst \u2014 a meta-retrospective engine that operates above individual strategy reviews.
+var ZOOM_OUT_SYSTEM_PROMPT = `You are the PAPI Zoom-Out Analyst \u2014 a strategic meta-retrospective engine that operates above individual strategy reviews.
 
-Strategy reviews look at 5-cycle windows. You look at the ENTIRE project history \u2014 every cycle, every decision, every pivot \u2014 and surface patterns that are invisible at the sprint level.
+Strategy reviews look at 5-cycle windows. You look at the full project arc \u2014 horizons, stages, decisions, pivots \u2014 and surface strategic patterns invisible at the sprint level. Focus on WHERE the project is going, not WHAT it recently did.
 
 IMPORTANT: You are running as a non-interactive API call. Do NOT ask questions or wait for confirmation. Be decisive and specific.
 
 ## OUTPUT FORMAT
 
-Produce a structured retrospective with these sections:
+Produce a strategic retrospective with these sections:
+
+### 1. Strategic Position
+Where is the project on its horizon/stage map? What stage gates have been passed and which are approaching? What has changed about the product's strategic position since the last zoom-out? How does the current trajectory compare to the North Star? 2-3 paragraphs, not a project history.
+
+### 2. Hard Questions
+5-7 questions the project must answer to advance to the next stage. These should be questions that strategy reviews are too narrow to surface \u2014 they require the full arc. For each question: state it, explain why it matters now, and what the cost of deferring it is.
 
-### 1. Project Arc
-Tell the story of this project in 3-5 paragraphs. What started as what? How did the vision evolve? What were the major inflection points? Where is it now? This should read like a concise project history that someone new could understand in 2 minutes.
+### 3. Horizon Assessment
+For each active horizon and stage in the hierarchy: what's the honest completion status? Are stages progressing or stalled? Are phases within stages actually delivering toward the stage goal, or is work scattered? Identify the 1-2 stages that are most at risk.
 
-### 2. Blind Spots
-What has the project consistently NOT looked at? Patterns of avoidance, areas that keep getting deferred, questions that keep being raised but never answered. These are the things that strategy reviews at the 5-cycle level miss because they lack the full arc.
+### 4. Blind Spots & Deferred Patterns
+What has the project consistently NOT addressed? Patterns of avoidance, questions raised but never answered, tasks deferred 3+ times. These compound invisibly. Focus on strategic blind spots (market, users, competition) not operational ones (code quality, test coverage).
 
-### 3. Risks
-Long-term risks that compound over time. Technical debt trends, strategic assumptions that haven't been validated, dependencies that are growing, scope patterns that suggest drift. Focus on risks that only become visible when you look at 20+ cycles of history.
+### 5. Opportunities
+Capabilities built but underutilised. Success patterns that could be amplified. Strategic positions that could be strengthened. What would a board advisor say the project should double down on?
 
-### 4. Opportunities
-What has the project proven that it hasn't capitalised on? Capabilities that were built but underutilised, patterns of success that could be amplified, strategic positions that could be strengthened. What would a board advisor say the project should double down on?
+### 6. Active Decision Health
+Audit every AD provided in context. For each, assess:
+- **Still relevant?** Does the decision actively guide current work, or is it stale/resolved?
+- **Correct confidence?** Does the evidence support the stated confidence level?
+- **Missing ADs?** Are there strategic conclusions from recent cycles that should be captured as new ADs but aren't?
+- **Wrong scope?** Are any ADs actually implementation details, config preferences, or process choices rather than product/architecture decisions?
 
-### 5. Weak Spots
-Where is the methodology itself failing? Are strategy reviews catching real issues? Are build reports accurate? Is the planning cycle producing the right tasks? Are decisions being made at the right time? Meta-level critique of how PAPI is being used on this project.
+Output a table: AD ID | Title | Verdict (Keep/Update/Supersede) | Reason. Then list any recommended new ADs with a one-line rationale.
 
-### 6. Recommendations
+### 7. Recommendations
 3-5 specific, actionable recommendations. Each must include:
 - **What:** The specific action
 - **Why:** What evidence from the full history supports this
@@ -15428,9 +17048,9 @@ Where is the methodology itself failing? Are strategy reviews catching real issu
 ## PRINCIPLES
 - Back every claim with specific cycle numbers, task IDs, or AD references.
 - Compare early project decisions with current reality \u2014 did assumptions hold?
-- Look for oscillation patterns (doing X, then undoing X, then re-doing X).
+- Focus on stages and horizons, not individual tasks or sprints.
 - Identify the 2-3 decisions that had the most outsized impact (positive or negative).
-- Be brutally honest. This is a retrospective, not a progress report.`;
+- Be brutally honest. This is a strategic assessment, not a progress report.`;
 async function prepareZoomOut(adapter2, projectRoot) {
   const health = await adapter2.getSprintHealth();
   const sprintNumber = health.totalSprints;