patchwarden 0.6.4 → 1.1.0

package/src/tools/safeStatus.ts

@@ -3,13 +3,26 @@ import { resolve, join } from "node:path";
 import { getTasksDir, getConfig, type PatchWardenConfig } from "../config.js";
 import { guardReadPath } from "../security/pathGuard.js";
 import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import type { TaskStatus, TaskPhase } from "./createTask.js";
+import type { TaskStatus, TaskPhase, AcceptanceStatus } from "./createTask.js";
 import { readTaskRuntime } from "../taskRuntime.js";
 import { readWatcherStatus } from "../watcherStatus.js";
+import { diagnoseTask, type DiagnosisType, type DiagnosisConfidence } from "./diagnoseTask.js";
 
 export interface SafeStatusOutput {
   task_id: string;
   status: TaskStatus | "not_found";
+  /**
+   * v0.7.0: For done_by_agent or accepted tasks, legacy_status echoes "done"
+   * so older UI/clients that do not understand those statuses still see a familiar value.
+   * Null for all other statuses.
+   */
+  legacy_status: "done" | null;
+  /**
+   * v0.7.0: Acceptance status — only meaningful for done_by_agent.
+   * - "pending": done_by_agent reached but not yet audited/accepted
+   * - null: status has no acceptance semantics
+   */
+  acceptance_status: AcceptanceStatus;
   phase: TaskPhase | null;
   created_at: string | null;
   started_at: string | null;
@@ -22,6 +35,20 @@ export interface SafeStatusOutput {
   watcher_state: string | null;
   error_code: string | null;
   error_summary: string | null;
+  /**
+   * v0.7.0: Seconds since the last heartbeat. Null when heartbeat is missing
+   * or unparseable. Used by callers to detect stale running tasks.
+   */
+  stale_seconds: number | null;
+  /**
+   * v0.7.0: Lightweight diagnosis snapshot derived from the same multi-signal
+   * logic as diagnose_task. Only the type/confidence are surfaced here;
+   * call diagnose_task for the full evidence and safe_actions.
+   *
+   * This field is null when status is already terminal (no diagnosis needed)
+   * or when diagnosis itself fails (do not block safe_status).
+   */
+  diagnosis: { type: DiagnosisType; confidence: DiagnosisConfidence } | null;
 }
 
 export function safeStatus(taskId: string, config?: PatchWardenConfig): SafeStatusOutput {
@@ -37,6 +64,8 @@ export function safeStatus(taskId: string, config?: PatchWardenConfig): SafeStat
     return {
       task_id: taskId,
       status: "not_found",
+      legacy_status: null,
+      acceptance_status: null,
       phase: null,
       created_at: null,
       started_at: null,
@@ -49,6 +78,8 @@ export function safeStatus(taskId: string, config?: PatchWardenConfig): SafeStat
       watcher_state: null,
       error_code: null,
       error_summary: null,
+      stale_seconds: null,
+      diagnosis: null,
     };
   }
 
@@ -77,9 +108,47 @@ export function safeStatus(taskId: string, config?: PatchWardenConfig): SafeStat
     errorSummary = `Task ended with status: ${status.status}`;
   }
 
+  // v0.7.2: derive legacy_status and acceptance_status
+  const statusStr = (status.status as TaskStatus) || "not_found";
+  const legacyStatus: "done" | null = (statusStr === "done_by_agent" || statusStr === "accepted") ? "done" : null;
+  const VALID_ACCEPTANCE: AcceptanceStatus[] = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
+  const acceptanceStatus: AcceptanceStatus = statusStr === "done_by_agent"
+    ? (typeof status.acceptance_status === "string" && VALID_ACCEPTANCE.includes(status.acceptance_status as AcceptanceStatus)
+      ? (status.acceptance_status as AcceptanceStatus)
+      : "pending") // default for done_by_agent when field missing
+    : null;
+
+  // v0.7.0: compute stale_seconds from the most recent heartbeat
+  const heartbeatStr =
+    (typeof runtime.last_heartbeat_at === "string" && runtime.last_heartbeat_at) ||
+    (typeof status.last_heartbeat_at === "string" && status.last_heartbeat_at) ||
+    (typeof status.updated_at === "string" && status.updated_at) ||
+    null;
+  let staleSeconds: number | null = null;
+  if (heartbeatStr) {
+    const heartbeatMs = Date.parse(heartbeatStr);
+    if (Number.isFinite(heartbeatMs)) {
+      staleSeconds = Math.max(0, Math.round((Date.now() - heartbeatMs) / 1000));
+    }
+  }
+
+  // v0.7.0: lightweight diagnosis snapshot — only for non-terminal tasks.
+  // Wrap in try/catch so a diagnosis failure never breaks safe_status.
+  let diagnosis: { type: DiagnosisType; confidence: DiagnosisConfidence } | null = null;
+  if (statusStr === "running" || statusStr === "collecting_artifacts" || statusStr === "pending") {
+    try {
+      const result = diagnoseTask({ task_id: taskId }, cfg);
+      diagnosis = { type: result.diagnosis, confidence: result.confidence };
+    } catch {
+      diagnosis = null;
+    }
+  }
+
   return {
     task_id: taskId,
-    status: (status.status as TaskStatus) || "not_found",
+    status: statusStr,
+    legacy_status: legacyStatus,
+    acceptance_status: acceptanceStatus,
     phase,
     created_at: typeof status.created_at === "string" ? status.created_at : null,
     started_at: typeof status.started_at === "string" ? status.started_at : null,
@@ -92,5 +161,7 @@ export function safeStatus(taskId: string, config?: PatchWardenConfig): SafeStat
     watcher_state: watcher.status,
     error_code: errorCode,
     error_summary: errorSummary,
+    stale_seconds: staleSeconds,
+    diagnosis,
   };
 }

package/src/tools/safeViews.ts

@@ -0,0 +1,271 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { getConfig, getTasksDir } from "../config.js";
+import { auditSession } from "./auditSession.js";
+import { auditTask, type AuditTaskOutput } from "./auditTask.js";
+import { finalizeDirectSession } from "./finalizeDirectSession.js";
+import { getTaskSummary } from "./getTaskSummary.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { redactSensitiveValue } from "../security/contentRedaction.js";
+import { readDirectSession, type DirectSessionRecord, type DirectSessionVerificationRun } from "../direct/directSessionStore.js";
+import type { ChangedFile, ClassifiedChange } from "../runner/changeCapture.js";
+
+export interface SafeViewOptions {
+  max_items?: number;
+}
+
+export function safeResult(taskId: string, options: SafeViewOptions = {}) {
+  const maxItems = normalizeMaxItems(options.max_items);
+  const summary = getTaskSummary(taskId, { view: "compact", max_items: maxItems });
+  return redact({
+    task_id: summary.task_id,
+    status: summary.status,
+    terminal: summary.terminal,
+    acceptance_status: summary.acceptance_status,
+    phase: summary.phase,
+    repo_path: summary.repo_path,
+    changed_files_total: summary.changed_files_total,
+    out_of_scope_changes_total: summary.out_of_scope_changes_total,
+    artifact_hygiene_counts: summary.artifact_hygiene.counts,
+    release_artifacts_count: summary.release_artifacts_count,
+    artifact_status: summary.artifact_status,
+    verification: summary.verification_summary,
+    warnings: limitStrings(summary.warnings, maxItems),
+    errors: limitStrings(summary.errors, maxItems),
+    failure_reason: summary.failure_reason,
+    failed_command: summary.failed_command,
+    next_action: summary.suggested_next_action,
+    execution_blocked: summary.execution_blocked,
+    pending_reason: summary.pending_reason,
+    redacted: summary.redacted,
+    redaction_categories: summary.redaction_categories,
+  });
+}
+
+export function safeTestSummary(taskId: string) {
+  const { taskDir, config } = getTaskDir(taskId);
+  const verify = readJson(join(taskDir, "verify.json"), config);
+  const summary = getTaskSummary(taskId, { view: "compact", max_items: 8 });
+  const commands = asArray(verify.commands).map((entry: any) => ({
+    command: String(entry.command || ""),
+    status: String(entry.status || "unknown"),
+    exit_code: entry.exit_code ?? null,
+    duration_ms: Number(entry.duration_ms || 0),
+  }));
+  return redact({
+    task_id: taskId,
+    status: String(verify.status || summary.verification_summary.status || "not_available"),
+    command_count: commands.length,
+    passed_commands: commands.filter((entry) => entry.status === "passed").length,
+    failed_commands: commands.filter((entry) => ["failed", "timed_out", "canceled"].includes(entry.status)).length,
+    skipped_commands: commands.filter((entry) => entry.status === "skipped").length,
+    commands,
+    headline: summary.verification_summary.headline,
+  });
+}
+
+export function safeDiffSummary(taskId: string, options: SafeViewOptions = {}) {
+  const maxItems = normalizeMaxItems(options.max_items);
+  const { taskDir, config } = getTaskDir(taskId);
+  const changes = readJson(join(taskDir, "changed-files.json"), config);
+  const changedFiles = asArray(changes.changed_files) as ChangedFile[];
+  const hygiene = asRecord(changes.artifact_hygiene);
+  return redact({
+    task_id: taskId,
+    changed_files_total: changedFiles.length,
+    additions: Number(changes.additions || 0),
+    deletions: Number(changes.deletions || 0),
+    diff_available: Boolean(changes.diff_available),
+    diff_truncated: Boolean(changes.diff_truncated),
+    patch_mode: changes.patch_mode || null,
+    files: changedFiles.slice(0, maxItems).map((file) => ({
+      path: file.path,
+      old_path: file.old_path || null,
+      change: file.change,
+      kind: file.kind,
+      tracked: Boolean(file.tracked),
+      ignored: Boolean(file.ignored),
+    })),
+    artifact_hygiene_counts: asRecord(hygiene.counts),
+    large_diff_omitted: true,
+    truncated: changedFiles.length > maxItems,
+  });
+}
+
+export function safeAudit(taskId: string, options: SafeViewOptions = {}) {
+  const maxItems = normalizeMaxItems(options.max_items);
+  return auditToSafe(auditTask(taskId) as AuditTaskOutput, maxItems);
+}
+
+export function safeDirectSummary(sessionId: string, options: SafeViewOptions = {}) {
+  const maxItems = normalizeMaxItems(options.max_items);
+  const session = readDirectSession(sessionId);
+  return directSessionToSafe(session, maxItems, "summary");
+}
+
+export function safeFinalizeDirectSession(sessionId: string, options: SafeViewOptions = {}) {
+  const maxItems = normalizeMaxItems(options.max_items);
+  const finalized = finalizeDirectSession({ session_id: sessionId });
+  const session = readDirectSession(sessionId);
+  return redact({
+    ...directSessionToSafe(session, maxItems, "finalize"),
+    finalized: finalized.finalized,
+    next_action: finalized.next_action,
+  });
+}
+
+export function safeAuditDirectSession(sessionId: string, options: SafeViewOptions = {}) {
+  const maxItems = normalizeMaxItems(options.max_items);
+  const audit = auditSession({ session_id: sessionId });
+  return redact({
+    session_id: audit.session_id,
+    decision: audit.decision,
+    reason_codes: audit.reason_codes.slice(0, maxItems),
+    blocking_findings: limitStrings(audit.blocking_findings, maxItems),
+    warnings: limitStrings(audit.warnings, maxItems),
+    evidence: {
+      changed_files_total: audit.evidence.changed_files_total,
+      verification_runs: summarizeVerificationRuns(audit.evidence.verification_runs),
+      diff_available: Boolean(audit.evidence.diff_path),
+      summary_available: Boolean(audit.evidence.summary_path),
+      audit_available: Boolean(audit.evidence.audit_path),
+    },
+    next_action: audit.next_action,
+  });
+}
+
+function auditToSafe(audit: AuditTaskOutput, maxItems: number) {
+  const checks = audit.checks.map((check) => ({
+    name: check.name,
+    result: check.result,
+    detail: truncate(check.detail, 240),
+  }));
+  return redact({
+    task_id: audit.task_id,
+    verdict: audit.verdict,
+    acceptance: {
+      verdict: audit.acceptance.verdict,
+      status: audit.acceptance.status,
+      reason: truncate(audit.acceptance.reason, 240),
+      fail_checks: audit.acceptance.fail_checks.slice(0, maxItems).map((check) => check.name),
+      warn_checks: audit.acceptance.warn_checks.slice(0, maxItems).map((check) => check.name),
+      next_suggested_task: truncate(audit.acceptance.next_suggested_task, 240),
+    },
+    check_counts: {
+      pass: checks.filter((check) => check.result === "pass").length,
+      warn: checks.filter((check) => check.result === "warn").length,
+      fail: checks.filter((check) => check.result === "fail").length,
+    },
+    checks: checks.slice(0, maxItems),
+    fail_checks: checks.filter((check) => check.result === "fail").slice(0, maxItems),
+    warn_checks: checks.filter((check) => check.result === "warn").slice(0, maxItems),
+    possible_false_positives: audit.possible_false_positives.slice(0, maxItems).map((item) => ({
+      check: item.check,
+      reason: truncate(item.reason, 240),
+    })),
+    manual_verification_required: audit.manual_verification_required,
+    manual_verification_items: limitStrings(audit.manual_verification_items, maxItems),
+    recommended_next_actions: limitStrings(audit.recommended_next_actions, maxItems),
+  });
+}
+
+function directSessionToSafe(session: DirectSessionRecord, maxItems: number, view: "summary" | "finalize") {
+  const artifacts = session.change_artifacts;
+  const changedFiles = artifacts?.changed_files || [];
+  return redact({
+    view,
+    session_id: session.session_id,
+    title: session.title || "",
+    repo_path: session.repo_path,
+    created_at: session.created_at,
+    expires_at: session.expires_at,
+    finalized: session.finalized,
+    finalized_at: session.finalized_at,
+    audited: session.audited,
+    changed_files_total: changedFiles.length,
+    files: changedFiles.slice(0, maxItems).map((file) => ({
+      path: file.path,
+      old_path: file.old_path || null,
+      change: file.change,
+      kind: file.kind,
+      tracked: Boolean(file.tracked),
+      ignored: Boolean(file.ignored),
+    })),
+    artifact_hygiene_counts: artifacts?.artifact_hygiene.counts || {},
+    source_changes: limitClassified(artifacts?.artifact_hygiene.source_changes, maxItems),
+    tracked_build_artifacts: limitClassified(artifacts?.artifact_hygiene.tracked_build_artifacts, maxItems),
+    runtime_generated_files: limitClassified(artifacts?.artifact_hygiene.runtime_generated_files, maxItems),
+    suspicious_changes: limitClassified(artifacts?.artifact_hygiene.suspicious_changes, maxItems),
+    verification: summarizeVerificationRuns(session.verification_runs),
+    large_diff_omitted: true,
+    truncated: changedFiles.length > maxItems,
+  });
+}
+
+function summarizeVerificationRuns(runs: DirectSessionVerificationRun[]) {
+  return runs.map((run) => ({
+    command: run.command,
+    exit_code: run.exit_code,
+    passed: run.passed,
+    timed_out: run.timed_out,
+    started_at: run.started_at,
+    finished_at: run.finished_at,
+  }));
+}
+
+function limitClassified(value: ClassifiedChange[] | undefined, maxItems: number) {
+  return (value || []).slice(0, maxItems).map((entry) => ({
+    path: entry.path,
+    change: entry.change,
+    kind: entry.kind,
+    tracked: entry.tracked,
+    ignored: entry.ignored,
+    reason: truncate(entry.reason, 160),
+  }));
+}
+
+function getTaskDir(taskId: string) {
+  const config = getConfig();
+  const taskDir = resolve(getTasksDir(config), taskId);
+  guardReadPath(join(taskDir, "status.json"), config.workspaceRoot, config.tasksDir);
+  return { config, taskDir };
+}
+
+function readJson(path: string, config: ReturnType<typeof getConfig>): Record<string, any> {
+  guardReadPath(path, config.workspaceRoot, config.tasksDir);
+  if (!existsSync(path)) return {};
+  try {
+    const raw = readFileSync(path, "utf-8").replace(/^\uFEFF/, "");
+    return asRecord(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+
+function normalizeMaxItems(value: number | undefined): number {
+  if (value === undefined) return 8;
+  if (!Number.isInteger(value) || value < 1 || value > 50) {
+    throw new Error("max_items must be an integer from 1 to 50.");
+  }
+  return value;
+}
+
+function asArray(value: unknown): any[] {
+  return Array.isArray(value) ? value : [];
+}
+
+function asRecord(value: unknown): Record<string, any> {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, any> : {};
+}
+
+function limitStrings(values: string[], maxItems: number): string[] {
+  return values.slice(0, maxItems).map((value) => truncate(value, 240));
+}
+
+function truncate(value: string, maxChars: number): string {
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...`;
+}
+
+function redact<T>(value: T): T {
+  return redactSensitiveValue(value).value as T;
+}

package/src/tools/schemaDriftCheck.ts

@@ -0,0 +1,120 @@
+/**
+ * v0.9.0: Schema 漂移检测模块。
+ *
+ * 检测 registry 元数据与实际工具 schema 是否漂移，
+ * 并聚合为可被 doctor 自检消费的 SchemaDriftResult。
+ *
+ * 本模块只做检测和报告，不做运行时阻断。
+ */
+
+import { computeSchemaDigest } from "./toolRegistry.js";
+import type { PatchWardenToolMeta } from "./toolRegistry.js";
+import { CHATGPT_CORE_TOOL_NAMES } from "./toolCatalog.js";
+
+// ── 结果类型 ──────────────────────────────────────────────────────
+
+export interface SchemaDriftResult {
+  /** true 表示无 drift，false 表示有 drift */
+  ok: boolean;
+  /** drift 描述列表（每个 drift 一条警告消息） */
+  warnings: string[];
+}
+
+/** toolDefs Map 的值类型：至少包含 inputSchema。 */
+export interface ToolDefLike {
+  inputSchema: unknown;
+}
+
+/** chatgpt_core profile 的预期工具数（来自 CHATGPT_CORE_TOOL_NAMES）。 */
+const EXPECTED_CORE_COUNT = CHATGPT_CORE_TOOL_NAMES.length;
+
+// ── 检查 1: registry schema digest 一致性 ─────────────────────────
+
+/**
+ * 检查 registry 中记录的 inputSchemaDigest 与实际 toolDef 的 inputSchema digest 是否一致。
+ * toolDefs 中找不到的工具会被跳过（不报 drift）。
+ */
+export function checkRegistrySchemaDigest(
+  registry: PatchWardenToolMeta[],
+  toolDefs: Map<string, ToolDefLike>,
+): SchemaDriftResult {
+  const warnings: string[] = [];
+  for (const meta of registry) {
+    const toolDef = toolDefs.get(meta.name);
+    if (!toolDef) continue; // toolDefs 中找不到该工具时跳过（不报 drift）
+    const actualDigest = computeSchemaDigest(toolDef.inputSchema);
+    if (actualDigest !== meta.inputSchemaDigest) {
+      warnings.push(
+        `Schema drift for tool '${meta.name}': registry digest ${meta.inputSchemaDigest} != actual digest ${actualDigest}`,
+      );
+    }
+  }
+  return { ok: warnings.length === 0, warnings };
+}
+
+// ── 检查 2: chatgpt_core manifest 稳定性 ──────────────────────────
+
+/**
+ * 校验 chatgpt_core profile 的工具 manifest 是否稳定。
+ *
+ * toolCatalog.ts 未导出独立的 manifest hash 计算函数（stableJson 为私有），
+ * 因此采用 fallback 方案：校验 CHATGPT_CORE_TOOL_NAMES 中的工具名
+ * 全部存在于 toolDefs 中（集合比较，不比较顺序——Map 迭代顺序取决于构造
+ * 方式，不一定与 chatgpt_core profile 顺序一致）。
+ *
+ * 真正的顺序稳定性由 CHATGPT_CORE_TOOL_NAMES 常量本身保证（顺序固定），
+ * 如果常量被修改，这里的名称集合比较也会检测到变化。
+ */
+export function checkChatgptCoreManifestStable(
+  toolDefs: Map<string, ToolDefLike>,
+): SchemaDriftResult {
+  const warnings: string[] = [];
+  const expected = [...CHATGPT_CORE_TOOL_NAMES];
+  // 检查 CHATGPT_CORE_TOOL_NAMES 中的每个工具是否都存在于 toolDefs
+  const missing = expected.filter((name) => !toolDefs.has(name));
+  if (missing.length > 0) {
+    warnings.push(
+      `chatgpt_core manifest has missing tools: ${missing.join(", ")} (expected ${EXPECTED_CORE_COUNT}, got ${EXPECTED_CORE_COUNT - missing.length})`,
+    );
+  }
+  return { ok: warnings.length === 0, warnings };
+}
+
+// ── 检查 3: chatgpt_core profile 工具数未变 ───────────────────────
+
+/**
+ * 校验 chatgpt_core profile 的工具数仍与 CHATGPT_CORE_TOOL_NAMES 一致。
+ * 用于检测是否有新工具被意外追加到 chatgpt_core profile。
+ */
+export function checkNewToolsProfileAppend(
+  registry: PatchWardenToolMeta[],
+): SchemaDriftResult {
+  const warnings: string[] = [];
+  const coreCount = registry.filter((t) => t.profiles.includes("chatgpt_core")).length;
+  if (coreCount !== EXPECTED_CORE_COUNT) {
+    warnings.push(
+      `chatgpt_core profile tool count changed: expected ${EXPECTED_CORE_COUNT}, got ${coreCount}`,
+    );
+  }
+  return { ok: warnings.length === 0, warnings };
+}
+
+// ── 聚合检查 ──────────────────────────────────────────────────────
+
+/**
+ * 聚合执行所有 schema drift 检查，合并 warnings。
+ * ok = warnings.length === 0
+ */
+export function runAllSchemaDriftChecks(
+  registry: PatchWardenToolMeta[],
+  toolDefs: Map<string, ToolDefLike>,
+): SchemaDriftResult {
+  const warnings: string[] = [];
+  const r1 = checkRegistrySchemaDigest(registry, toolDefs);
+  warnings.push(...r1.warnings);
+  const r2 = checkChatgptCoreManifestStable(toolDefs);
+  warnings.push(...r2.warnings);
+  const r3 = checkNewToolsProfileAppend(registry);
+  warnings.push(...r3.warnings);
+  return { ok: warnings.length === 0, warnings };
+}

package/src/tools/toolCatalog.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../version.js";
 
-export type ToolProfile = "full" | "chatgpt_core" | "chatgpt_direct";
+export type ToolProfile = "full" | "chatgpt_core" | "chatgpt_direct" | "chatgpt_search";
 
 export interface CatalogTool {
   name: string;
@@ -36,6 +36,10 @@ export const CHATGPT_CORE_TOOL_NAMES = [
   "cancel_task",
   "audit_task",
   "safe_status",
+  "safe_result",
+  "safe_audit",
+  "safe_test_summary",
+  "safe_diff_summary",
 ] as const;
 
 export const CHATGPT_DIRECT_TOOL_NAMES = [
@@ -48,15 +52,26 @@ export const CHATGPT_DIRECT_TOOL_NAMES = [
   "run_verification",
   "finalize_direct_session",
   "audit_session",
+  "safe_direct_summary",
+  "safe_finalize_direct_session",
+  "safe_audit_direct_session",
   "sync_file",
 ] as const;
 
+export const CHATGPT_SEARCH_TOOL_NAMES = [
+  "health_check",
+  "discover_tools",
+  "explain_tool",
+  "invoke_discovered_tool",
+  "safe_status",
+] as const;
+
 let lastSnapshot: ToolCatalogSnapshot | null = null;
 
 export function resolveToolProfile(configProfile?: string): ToolProfile {
   const raw = (process.env.PATCHWARDEN_TOOL_PROFILE || configProfile || "full").trim();
-  if (raw !== "full" && raw !== "chatgpt_core" && raw !== "chatgpt_direct") {
-    throw new Error(`Invalid tool profile "${raw}". Expected "full", "chatgpt_core", or "chatgpt_direct".`);
+  if (raw !== "full" && raw !== "chatgpt_core" && raw !== "chatgpt_direct" && raw !== "chatgpt_search") {
+    throw new Error(`Invalid tool profile "${raw}". Expected "full", "chatgpt_core", "chatgpt_direct", or "chatgpt_search".`);
   }
   return raw;
 }
@@ -73,17 +88,25 @@ export function selectToolsForProfile<T extends CatalogTool>(tools: T[], profile
     });
   }
 
-  // chatgpt_direct
-  if (!enableDirectProfile) {
-    // Degraded mode: only expose health_check for diagnostics
-    const tool = byName.get("health_check");
-    if (!tool) throw new Error(`chatgpt_direct degraded mode requires missing tool "health_check".`);
-    return [tool];
+  if (profile === "chatgpt_direct") {
+    if (!enableDirectProfile) {
+      // Degraded mode: only expose health_check for diagnostics
+      const tool = byName.get("health_check");
+      if (!tool) throw new Error(`chatgpt_direct degraded mode requires missing tool "health_check".`);
+      return [tool];
+    }
+
+    return CHATGPT_DIRECT_TOOL_NAMES.map((name) => {
+      const tool = byName.get(name);
+      if (!tool) throw new Error(`chatgpt_direct tool profile requires missing tool "${name}".`);
+      return tool;
+    });
   }
 
-  return CHATGPT_DIRECT_TOOL_NAMES.map((name) => {
+  // chatgpt_search: compact profile, 5 tools all required, no degraded mode
+  return CHATGPT_SEARCH_TOOL_NAMES.map((name) => {
     const tool = byName.get(name);
-    if (!tool) throw new Error(`chatgpt_direct tool profile requires missing tool "${name}".`);
+    if (!tool) throw new Error(`chatgpt_search tool profile requires missing tool "${name}".`);
     return tool;
   });
 }