claude-ws 0.4.9-beta.3 → 0.4.9-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-ws",
-  "version": "0.4.9-beta.3",
+  "version": "0.4.9-beta.5",
   "private": false,
   "description": "AI-powered workspace for solo CEOs and indie builders — manage your entire business with AI agents, not just code. Kanban board, code editor, Git integration, claw agent hub, local-first SQLite.",
   "keywords": [
@@ -90,9 +90,11 @@
     "pm2-logs": "pm2 logs claudews",
     "pm2-monit": "pm2 monit",
     "build": "cross-env NODE_ENV=production next build",
-    "start": "cross-env NODE_ENV=production tsx server.ts",
+    "start": "pnpm projects:migrate:defaults && cross-env NODE_ENV=production tsx server.ts",
     "db:generate": "drizzle-kit generate",
     "db:fix": "tsx scripts/db-fix-columns.ts",
+    "db:migrate:health": "tsx scripts/db-migrate-health.ts",
+    "projects:migrate:defaults": "tsx scripts/migrate-existing-projects.ts",
     "migrate:sessions": "tsx scripts/migrate-sdk-sessions.ts"
   },
   "dependencies": {
@@ -139,9 +141,9 @@
     "@tailwindcss/postcss": "^4.2.2",
     "@types/adm-zip": "^0.5.8",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/js-yaml": "^4.0.9",
     "@types/compression": "^1.8.1",
     "@types/dompurify": "^3.2.0",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.19.37",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
@@ -201,5 +203,8 @@
   "optionalDependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",
     "node-pty": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9"
   }
 }

package/packages/agentic-sdk/src/lib/output-formatter.ts

@@ -24,6 +24,8 @@ interface ClaudeOutput {
 interface FormattedResponse {
   formatted_data: string;
   format: string;
+  messages?: ClaudeOutput[];
+  status?: string;
   attempt: {
     id: string;
     taskId: string;
@@ -75,9 +77,21 @@ export function formatOutput(
         break;
     }
 
-    return { formatted_data: formattedData, format, attempt: { ...attemptMetadata, status: attemptMetadata.status as any } };
+    return {
+      formatted_data: formattedData,
+      format,
+      messages,
+      status: attemptMetadata.status as any,
+      attempt: { ...attemptMetadata, status: attemptMetadata.status as any }
+    };
   } catch {
-    return { formatted_data: toJson(messages), format: 'json', attempt: { ...attemptMetadata, status: attemptMetadata.status as any } };
+    return {
+      formatted_data: toJson(messages),
+      format: 'json',
+      messages,
+      status: attemptMetadata.status as any,
+      attempt: { ...attemptMetadata, status: attemptMetadata.status as any }
+    };
   }
 }
 

package/scripts/db-migrate-health.ts

@@ -0,0 +1,223 @@
+#!/usr/bin/env tsx
+/**
+ * Database health migration script
+ *
+ * Goals:
+ * - Backup database before touching data
+ * - Add legacy missing columns (idempotent)
+ * - Clean orphan rows that can trigger FK-related runtime errors
+ * - Verify FK integrity after cleanup
+ *
+ * Usage:
+ *   pnpm db:migrate:health
+ */
+
+import Database from 'better-sqlite3';
+import path from 'path';
+import fs from 'fs';
+import { config } from 'dotenv';
+
+type CleanupItem = {
+  label: string;
+  run: (db: Database.Database) => number;
+};
+
+function nowStamp(): string {
+  const d = new Date();
+  const pad = (n: number) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+
+function addColumnIfMissing(db: Database.Database, table: string, column: string, type: string): boolean {
+  try {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ensureLegacyColumns(db: Database.Database): number {
+  let added = 0;
+  const attemptsColumns = [
+    ['total_tokens', 'INTEGER NOT NULL DEFAULT 0'],
+    ['input_tokens', 'INTEGER NOT NULL DEFAULT 0'],
+    ['output_tokens', 'INTEGER NOT NULL DEFAULT 0'],
+    ['cache_creation_tokens', 'INTEGER NOT NULL DEFAULT 0'],
+    ['cache_read_tokens', 'INTEGER NOT NULL DEFAULT 0'],
+    ['total_cost_usd', "TEXT NOT NULL DEFAULT '0'"],
+    ['num_turns', 'INTEGER NOT NULL DEFAULT 0'],
+    ['duration_ms', 'INTEGER NOT NULL DEFAULT 0'],
+    ['context_used', 'INTEGER NOT NULL DEFAULT 0'],
+    ['context_limit', 'INTEGER NOT NULL DEFAULT 200000'],
+    ['context_percentage', 'INTEGER NOT NULL DEFAULT 0'],
+    ['baseline_context', 'INTEGER NOT NULL DEFAULT 0'],
+    ['output_format', 'TEXT'],
+    ['output_schema', 'TEXT'],
+  ] as const;
+
+  const tasksColumns = [
+    ['chat_init', 'INTEGER NOT NULL DEFAULT 0'],
+    ['rewind_session_id', 'TEXT'],
+    ['rewind_message_uuid', 'TEXT'],
+    ['last_model', 'TEXT'],
+    ['last_provider', 'TEXT'],
+    ['pending_file_ids', 'TEXT'],
+  ] as const;
+
+  const checkpointsColumns = [
+    ['git_commit_hash', 'TEXT'],
+  ] as const;
+
+  for (const [name, type] of attemptsColumns) if (addColumnIfMissing(db, 'attempts', name, type)) added++;
+  for (const [name, type] of tasksColumns) if (addColumnIfMissing(db, 'tasks', name, type)) added++;
+  for (const [name, type] of checkpointsColumns) if (addColumnIfMissing(db, 'checkpoints', name, type)) added++;
+
+  return added;
+}
+
+function deleteCount(db: Database.Database, sql: string): number {
+  const stmt = db.prepare(sql);
+  const result = stmt.run();
+  return Number(result.changes || 0);
+}
+
+function updateCount(db: Database.Database, sql: string): number {
+  const stmt = db.prepare(sql);
+  const result = stmt.run();
+  return Number(result.changes || 0);
+}
+
+function run(): void {
+  const userCwd = process.env.CLAUDE_WS_USER_CWD || process.cwd();
+  config({ path: path.join(userCwd, '.env') });
+
+  const dbDir = process.env.DATA_DIR || path.join(userCwd, 'data');
+  const dbPath = path.join(dbDir, 'claude-ws.db');
+
+  if (!fs.existsSync(dbPath)) {
+    console.log(`[db:migrate:health] DB not found: ${dbPath}`);
+    process.exit(0);
+  }
+
+  fs.mkdirSync(dbDir, { recursive: true });
+  const backupPath = path.join(dbDir, `claude-ws.db.backup-${nowStamp()}`);
+  fs.copyFileSync(dbPath, backupPath);
+  console.log(`[db:migrate:health] Backup created: ${backupPath}`);
+
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+
+  const fkBefore = db.prepare('PRAGMA foreign_key_check').all() as any[];
+  console.log(`[db:migrate:health] FK violations before: ${fkBefore.length}`);
+
+  const cleanup: CleanupItem[] = [
+    { label: 'tasks without project', run: (x) => deleteCount(x, `DELETE FROM tasks WHERE project_id NOT IN (SELECT id FROM projects)`) },
+    { label: 'attempts without task', run: (x) => deleteCount(x, `DELETE FROM attempts WHERE task_id NOT IN (SELECT id FROM tasks)`) },
+    { label: 'attempt_logs without attempt', run: (x) => deleteCount(x, `DELETE FROM attempt_logs WHERE attempt_id NOT IN (SELECT id FROM attempts)`) },
+    { label: 'attempt_files without attempt', run: (x) => deleteCount(x, `DELETE FROM attempt_files WHERE attempt_id NOT IN (SELECT id FROM attempts)`) },
+    {
+      label: 'checkpoints without task/attempt',
+      run: (x) => deleteCount(
+        x,
+        `DELETE FROM checkpoints
+         WHERE task_id NOT IN (SELECT id FROM tasks)
+            OR attempt_id NOT IN (SELECT id FROM attempts)`
+      ),
+    },
+    {
+      label: 'shells with missing attempt -> NULL',
+      run: (x) => updateCount(
+        x,
+        `UPDATE shells
+         SET attempt_id = NULL
+         WHERE attempt_id IS NOT NULL
+           AND attempt_id NOT IN (SELECT id FROM attempts)`
+      ),
+    },
+    {
+      label: 'project_plugins orphan refs',
+      run: (x) => deleteCount(
+        x,
+        `DELETE FROM project_plugins
+         WHERE project_id NOT IN (SELECT id FROM projects)
+            OR plugin_id NOT IN (SELECT id FROM agent_factory_plugins)`
+      ),
+    },
+    {
+      label: 'plugin_dependencies without owner plugin',
+      run: (x) => deleteCount(
+        x,
+        `DELETE FROM plugin_dependencies
+         WHERE plugin_id NOT IN (SELECT id FROM agent_factory_plugins)`
+      ),
+    },
+    {
+      label: 'plugin_dependencies missing referenced plugin -> NULL',
+      run: (x) => updateCount(
+        x,
+        `UPDATE plugin_dependencies
+         SET plugin_dependency_id = NULL
+         WHERE plugin_dependency_id IS NOT NULL
+           AND plugin_dependency_id NOT IN (SELECT id FROM agent_factory_plugins)`
+      ),
+    },
+    {
+      label: 'plugin_dependency_cache missing plugin -> NULL',
+      run: (x) => updateCount(
+        x,
+        `UPDATE plugin_dependency_cache
+         SET plugin_id = NULL
+         WHERE plugin_id IS NOT NULL
+           AND plugin_id NOT IN (SELECT id FROM agent_factory_plugins)`
+      ),
+    },
+    {
+      label: 'subagents without attempt',
+      run: (x) => deleteCount(x, `DELETE FROM subagents WHERE attempt_id NOT IN (SELECT id FROM attempts)`),
+    },
+    {
+      label: 'tracked_tasks without attempt',
+      run: (x) => deleteCount(x, `DELETE FROM tracked_tasks WHERE attempt_id NOT IN (SELECT id FROM attempts)`),
+    },
+    {
+      label: 'agent_messages without attempt',
+      run: (x) => deleteCount(x, `DELETE FROM agent_messages WHERE attempt_id NOT IN (SELECT id FROM attempts)`),
+    },
+  ];
+
+  const tx = db.transaction(() => {
+    const addedColumns = ensureLegacyColumns(db);
+    console.log(`[db:migrate:health] Added missing columns: ${addedColumns}`);
+
+    let totalChanges = 0;
+    for (const item of cleanup) {
+      const changed = item.run(db);
+      totalChanges += changed;
+      if (changed > 0) {
+        console.log(`[db:migrate:health] ${item.label}: ${changed}`);
+      }
+    }
+    return totalChanges;
+  });
+
+  const changedRows = tx();
+
+  const fkAfter = db.prepare('PRAGMA foreign_key_check').all() as any[];
+  const quickCheck = db.prepare('PRAGMA quick_check').get() as { quick_check?: string } | undefined;
+  db.close();
+
+  console.log(`[db:migrate:health] Total repaired rows: ${changedRows}`);
+  console.log(`[db:migrate:health] FK violations after: ${fkAfter.length}`);
+  console.log(`[db:migrate:health] quick_check: ${quickCheck?.quick_check ?? 'unknown'}`);
+
+  if (fkAfter.length > 0) {
+    console.log('[db:migrate:health] WARNING: FK violations remain. Restore backup and inspect manually if needed.');
+    process.exit(1);
+  }
+
+  console.log('[db:migrate:health] Done.');
+}
+
+run();

package/scripts/migrate-existing-projects.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env tsx
+/**
+ * Migrate existing projects to current default Claude workspace structure.
+ *
+ * What it does per project:
+ * - Ensures `.claude/hooks` and `.claude/commands` exist
+ * - Syncs hook templates (`minio-pull-sync.ts`, `minio-push-sync.ts`)
+ * - Ensures `.claude/hooks/.env.example`, `.claude/settings.json`, `.claude/CLAUDE.md`
+ * - Creates `.claude/hooks/.env` when missing
+ *
+ * Usage:
+ *   pnpm projects:migrate:defaults
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { config } from 'dotenv';
+import { db, schema } from '../src/lib/db';
+import { setupProjectDefaults } from '../src/lib/project-utils';
+
+type ProjectTarget = {
+  id: string;
+  projectPath: string;
+  source: 'db' | 'scan';
+};
+
+function inferProjectIdFromDirName(dirName: string): string {
+  // Folders may be: "<projectId>" or "<projectId>-<name>"
+  const firstDash = dirName.indexOf('-');
+  if (firstDash <= 0) return dirName;
+  return dirName.slice(0, firstDash);
+}
+
+async function run(): Promise<void> {
+  const workspaceRoot = process.env.CLAUDE_WS_USER_CWD || process.cwd();
+  config({ path: path.join(workspaceRoot, '.env') });
+
+  const dataDir = process.env.DATA_DIR || path.join(workspaceRoot, 'data');
+  const projectsDir = path.join(dataDir, 'projects');
+
+  const targets = new Map<string, ProjectTarget>();
+
+  // 1) Projects tracked in DB
+  const dbProjects = db.select({
+    id: schema.projects.id,
+    path: schema.projects.path,
+  }).from(schema.projects).all();
+
+  for (const p of dbProjects) {
+    targets.set(path.resolve(p.path), {
+      id: p.id,
+      projectPath: path.resolve(p.path),
+      source: 'db',
+    });
+  }
+
+  // 2) Extra dirs under data/projects not present in DB
+  if (fs.existsSync(projectsDir)) {
+    const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const projectPath = path.resolve(path.join(projectsDir, entry.name));
+      if (targets.has(projectPath)) continue;
+      targets.set(projectPath, {
+        id: inferProjectIdFromDirName(entry.name),
+        projectPath,
+        source: 'scan',
+      });
+    }
+  }
+
+  if (targets.size === 0) {
+    console.log('[projects:migrate:defaults] No projects found.');
+    return;
+  }
+
+  console.log(`[projects:migrate:defaults] Found ${targets.size} projects.`);
+
+  let ok = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const target of targets.values()) {
+    try {
+      if (!fs.existsSync(target.projectPath)) {
+        console.log(`[projects:migrate:defaults] SKIP missing path: ${target.projectPath}`);
+        skipped++;
+        continue;
+      }
+
+      await setupProjectDefaults(target.projectPath, target.id, workspaceRoot);
+      console.log(`[projects:migrate:defaults] OK ${target.source} id=${target.id} path=${target.projectPath}`);
+      ok++;
+    } catch (error) {
+      console.error(`[projects:migrate:defaults] FAIL id=${target.id} path=${target.projectPath}`, error);
+      failed++;
+    }
+  }
+
+  console.log(`[projects:migrate:defaults] Done. ok=${ok} skipped=${skipped} failed=${failed}`);
+  if (failed > 0) process.exit(1);
+}
+
+run().catch((error) => {
+  console.error('[projects:migrate:defaults] Fatal error', error);
+  process.exit(1);
+});

package/server.ts

@@ -59,6 +59,13 @@ import type { AutopilotMode } from './src/lib/autopilot';
 
 import { getPort, getHostname } from './src/lib/server-port-configuration';
 
+function isSqliteForeignKeyError(error: unknown): boolean {
+  if (!error || typeof error !== 'object') return false;
+  const maybeError = error as { code?: string; message?: string };
+  return maybeError.code === 'SQLITE_CONSTRAINT_FOREIGNKEY'
+    || (typeof maybeError.message === 'string' && maybeError.message.includes('FOREIGN KEY constraint failed'));
+}
+
 const dev = process.env.NODE_ENV !== 'production';
 const hostname = getHostname();
 const port = getPort();
@@ -72,6 +79,26 @@ app.prepare().then(async () => {
   const httpServer = createServer((req, res) => {
     const parsedUrl = parse(req.url!, true);
     const pathname = parsedUrl.pathname || '';
+    const requestStartedAt = Date.now();
+    const shouldTraceRequest =
+      pathname.startsWith('/api/attempts')
+      || pathname.includes('/conversation')
+      || pathname.includes('/running-attempt')
+      || pathname.includes('/pending-question')
+      || pathname.includes('/agent-factory/projects/');
+
+    if (shouldTraceRequest) {
+      res.on('finish', () => {
+        const durationMs = Date.now() - requestStartedAt;
+        log.info({
+          method: req.method,
+          path: pathname,
+          statusCode: res.statusCode,
+          durationMs,
+          hasApiKey: Boolean(req.headers['x-api-key']),
+        }, '[Server] HTTP request traced');
+      });
+    }
 
     // API authentication check - read from process.env directly for immediate effect
     const apiAccessKey = process.env.API_ACCESS_KEY;
@@ -1036,11 +1063,19 @@ app.prepare().then(async () => {
 
     if (!isStreamingDelta) {
       // Save to database (only complete messages)
-      await db.insert(schema.attemptLogs).values({
-        attemptId,
-        type: 'json',
-        content: JSON.stringify(data),
-      });
+      try {
+        await db.insert(schema.attemptLogs).values({
+          attemptId,
+          type: 'json',
+          content: JSON.stringify(data),
+        });
+      } catch (error) {
+        if (isSqliteForeignKeyError(error)) {
+          log.warn({ attemptId }, '[Server] Skipping JSON log write because attempt no longer exists');
+        } else {
+          throw error;
+        }
+      }
     }
 
     // Check how many clients are in the room
@@ -1106,11 +1141,19 @@ app.prepare().then(async () => {
   });
 
   agentManager.on('stderr', async ({ attemptId, content }) => {
-    await db.insert(schema.attemptLogs).values({
-      attemptId,
-      type: 'stderr',
-      content,
-    });
+    try {
+      await db.insert(schema.attemptLogs).values({
+        attemptId,
+        type: 'stderr',
+        content,
+      });
+    } catch (error) {
+      if (isSqliteForeignKeyError(error)) {
+        log.warn({ attemptId }, '[Server] Skipping stderr log write because attempt no longer exists');
+      } else {
+        throw error;
+      }
+    }
 
     io.to(`attempt:${attemptId}`).emit('output:stderr', { attemptId, content });
   });
@@ -1382,6 +1425,7 @@ app.prepare().then(async () => {
 
   // Register exit event handler
   agentManager.on('exit', async ({ attemptId, code }) => {
+    try {
     // Get attempt to retrieve taskId and current status
     const attempt = await db.query.attempts.findFirst({
       where: eq(schema.attempts.id, attemptId),
@@ -1599,6 +1643,13 @@ app.prepare().then(async () => {
     usageTracker.clearSession(attemptId);
     workflowTracker.clearWorkflow(attemptId);
     gitStatsCache.clear(attemptId);
+    } catch (error) {
+      if (isSqliteForeignKeyError(error)) {
+        log.warn({ attemptId }, '[Server] Ignoring FK error in exit handler (attempt/task deleted)');
+      } else {
+        log.error({ attemptId, error }, '[Server] Exit handler failed');
+      }
+    }
   });
 
   // Forward tracking module events to Socket.io clients

package/src/app/api/agent-factory/projects/[projectId]/sync/route.ts

@@ -82,6 +82,14 @@ export async function POST(
       return NextResponse.json({ error: 'Project not found' }, { status: 404 });
     }
 
+    log.info(
+      {
+        projectId,
+        projectPath: project.path,
+      },
+      'Resolved project path for sync'
+    );
+
     let parsedBody: unknown = {};
     try {
       parsedBody = await request.json();
@@ -95,6 +103,7 @@ export async function POST(
     log.info(
       {
         projectId,
+        projectPath: project.path,
         body,
         componentIds,
         agentSetIds,
@@ -106,12 +115,39 @@ export async function POST(
       await upsertProjectSettings(project.path, componentIds, agentSetIds);
     }
 
+    log.info(
+      {
+        projectId,
+        projectPath: project.path,
+      },
+      'Starting AgentFactory project sync'
+    );
+
     const result = await agentFactoryService.syncProject(projectId, project.path);
 
     if (!result.success && result.error) {
+      log.warn(
+        {
+          projectId,
+          projectPath: project.path,
+          error: result.error,
+        },
+        'AgentFactory project sync failed'
+      );
       return NextResponse.json({ error: result.error }, { status: 400 });
     }
 
+    log.info(
+      {
+        projectId,
+        projectPath: project.path,
+        installedCount: result.installed?.length ?? 0,
+        skippedCount: result.skipped?.length ?? 0,
+        errorCount: result.errors?.length ?? 0,
+      },
+      'AgentFactory project sync completed'
+    );
+
     return NextResponse.json({
       success: true,
       message: `Installed ${result.installed?.length ?? 0} components to project`,

package/src/hooks/template/hooks/.env.example

@@ -7,4 +7,7 @@
 API_HOOK_URL_LOCAL="http://localhost:5005/api/sync/"
 API_HOOK_URL_DOMAIN="https://privos-chat-dev.roxane.one/api/v1/internal/rooms/room_id/files/"
 API_HOOK_API_KEY=
+API_QUEUE_URL="http://localhost:8052"
+# Optional comma-separated extra queue endpoints/base URLs
+# API_QUEUE_FALLBACK_URLS="http://localhost:8053,http://localhost:3000"
 PROJECT_ID="your-project-id"

package/src/hooks/template/hooks/minio-pull-sync.ts

@@ -20,6 +20,8 @@ if (!config.apiBaseUrl) {
 }
 
 const PULL_DB_PATH = path.join(hooksDir, "pull-sync-state.db");
+const TMP_DIR = path.join(process.cwd(), ".claude", "tmp");
+const PUSH_STATE_FILE = path.join(TMP_DIR, "local-sync-state.json");
 
 function buildApiUrl(endpoint: string): string {
   const base = String(config.apiBaseUrl || "").replace(/\/+$/g, "");
@@ -111,12 +113,17 @@ async function ensurePullDb(): Promise<Database.Database> {
   return sqlite;
 }
 
-async function fetchManifest(folder: string, label: string): Promise<ManifestEntry[]> {
+async function fetchManifest(folder: string, label: string, allowNotFound = false): Promise<ManifestEntry[]> {
   console.error(`🔍 Calling API to get manifest for '${label}' (${folder})...`);
 
   const url = buildApiUrl(`manifest?folder=${encodeURIComponent(folder)}`);
   const response = await fetch(url, { headers: buildApiHeaders() });
 
+  if (response.status === 404 && allowNotFound) {
+    console.error(`ℹ️ ${label} not found on remote, treating as empty manifest.`);
+    return [];
+  }
+
   if (!response.ok) {
     throw new Error(`API manifest failed for ${label}: HTTP ${response.status} ${response.statusText}`);
   }
@@ -132,13 +139,13 @@ async function fetchManifest(folder: string, label: string): Promise<ManifestEnt
   return objects;
 }
 
-async function getQueueCandidates(): Promise<QueueFileCandidate[]> {
+async function getQueueCandidates(): Promise<{ candidates: QueueFileCandidate[]; manifestData: ManifestEntry[] }> {
   const mainPrefix = config.projectId;
   const markdownPrefix = `markdown/${config.projectId}`;
 
   const [mainManifest, markdownManifest] = await Promise.all([
     fetchManifest(mainPrefix, "main folder"),
-    fetchManifest(markdownPrefix, "markdown folder"),
+    fetchManifest(markdownPrefix, "markdown folder", true),
   ]);
 
   const normalize = (entries: ManifestEntry[], folder: FolderType): QueueFileCandidate[] => (
@@ -152,7 +159,15 @@ async function getQueueCandidates(): Promise<QueueFileCandidate[]> {
     }))
   );
 
-  return [...normalize(mainManifest, "main"), ...normalize(markdownManifest, "markdown")];
+  return {
+    candidates: [...normalize(mainManifest, "main"), ...normalize(markdownManifest, "markdown")],
+    manifestData: [...mainManifest, ...markdownManifest],
+  };
+}
+
+async function writePushStateFile(manifestData: ManifestEntry[]): Promise<void> {
+  await fs.mkdir(TMP_DIR, { recursive: true });
+  await fs.writeFile(PUSH_STATE_FILE, JSON.stringify(manifestData, null, 2), "utf-8");
 }
 
 function enqueueCandidates(
@@ -249,12 +264,14 @@ async function runEnqueue() {
   let sqlite: Database.Database | null = null;
   try {
     console.error("\n=================== ENQUEUE MINIO PULL JOB ===================");
-    const candidates = await getQueueCandidates();
+    const { candidates, manifestData } = await getQueueCandidates();
+    await writePushStateFile(manifestData);
 
     sqlite = await ensurePullDb();
     const result = enqueueCandidates(sqlite, candidates);
 
     console.error(`✅ Queue DB: ${PULL_DB_PATH}`);
+    console.error(`✅ Push state file: ${PUSH_STATE_FILE}`);
     console.error(`🧾 Job ID: ${result.jobId}`);
     console.error(`📊 Total: ${result.totalFiles} | Enqueued: ${result.enqueuedFiles} | Skipped: ${result.skippedFiles}`);
     console.error(`📌 Job status: ${result.status}`);

package/src/hooks/template/hooks/minio-push-sync.ts

@@ -35,6 +35,12 @@ function createConcurrencyLimit(concurrency: number) {
 const config = {
     apiBaseUrl: process.env.API_HOOK_URL as string,
     apiHookApiKey: (process.env.API_HOOK_API_KEY || "").trim(),
+    apiQueueUrl: (process.env.API_QUEUE_URL || process.env.CLAUDE_WS_API_BASE_URL || "").trim(),
+    apiQueueFallbackUrls: (process.env.API_QUEUE_FALLBACK_URLS || "").trim(),
+    apiQueueKey: (process.env.API_HOOK_KEY || process.env.API_ACCESS_KEY || "").trim(),
+    appPort: (process.env.PORT || "").trim(),
+    queueHost: (process.env.API_QUEUE_HOST || "localhost").trim(),
+    projectId: (process.env.PROJECT_ID || "__PROJECT_ID__") as string,
     targetPrefix: (process.env.PROJECT_ID || "__PROJECT_ID__") as string,
 };
 
@@ -63,6 +69,83 @@ function buildApiHeaders(baseHeaders: Record<string, string> = {}): HeadersInit
     return headers;
 }
 
+function toPushEndpoint(baseOrEndpoint: string): string {
+    const trimmed = String(baseOrEndpoint || "").trim().replace(/\/+$/g, "");
+    if (!trimmed) return "";
+    if (/\/api\/sync\/minio\/push$/i.test(trimmed)) return trimmed;
+    return `${trimmed}/api/sync/minio/push`;
+}
+
+function buildQueueCandidates(): string[] {
+    const candidates: string[] = [];
+    const push = (value: string) => {
+        const endpoint = toPushEndpoint(value);
+        if (endpoint && !candidates.includes(endpoint)) {
+            candidates.push(endpoint);
+        }
+    };
+
+    // Highest priority: explicit queue base URL
+    if (config.apiQueueUrl) {
+        push(config.apiQueueUrl);
+    }
+
+    // Default queue endpoint: localhost + PORT from environment
+    if (!config.apiQueueUrl && config.appPort) {
+        push(`http://${config.queueHost}:${config.appPort}`);
+    }
+
+    // Optional comma-separated list of extra queue base URLs/endpoints
+    if (config.apiQueueFallbackUrls) {
+        for (const raw of config.apiQueueFallbackUrls.split(",")) {
+            const value = raw.trim();
+            if (value) push(value);
+        }
+    }
+
+    // Last fallback: same origin as sync API base
+    try {
+        const origin = new URL(config.apiBaseUrl).origin;
+        push(origin);
+    } catch {
+        // ignore invalid URL
+    }
+
+    return candidates;
+}
+
+async function enqueuePushJob(): Promise<boolean> {
+    const endpoints = buildQueueCandidates();
+    if (endpoints.length === 0) return false;
+
+    for (const endpoint of endpoints) {
+        try {
+            const headers: Record<string, string> = { "Content-Type": "application/json" };
+            if (config.apiQueueKey) {
+                headers["x-api-key"] = config.apiQueueKey;
+            }
+
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ projectId: config.projectId }),
+            });
+
+            if (response.ok) {
+                console.error(`✅ Queue accepted via ${endpoint}`);
+                return true;
+            }
+
+            console.error(`⚠️ Queue endpoint failed ${endpoint}: HTTP ${response.status}`);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`⚠️ Queue endpoint unreachable ${endpoint}: ${message}`);
+        }
+    }
+
+    return false;
+}
+
 // Function to create tmp directory
 async function ensureTmpDir() {
     await fs.mkdir(TMP_DIR, { recursive: true });
@@ -138,6 +221,14 @@ async function scanDirectory(dir: string, fileList: string[] = []) {
 // MAIN SYNC FUNCTION
 // ==========================================
 async function runCheck() {
+    // Preferred path: enqueue into server-side push queue (records jobs in push-sync-state.db)
+    const enqueued = await enqueuePushJob();
+    if (enqueued) {
+        return;
+    }
+
+    console.error("⚠️ Queue enqueue failed on all endpoints, falling back to direct upload mode.");
+
     await ensureTmpDir(); // Create tmp directory before running
     console.error(`🔍 Starting to scan files in '${LOCAL_DATA_DIR}' and compare with '${STATE_FILE}'...`);
 

package/src/lib/db/index.ts

@@ -268,6 +268,17 @@ export function initDb() {
       // Column already exists
     }
   }
+
+  // Cleanup inconsistent legacy rows created while FK checks were disabled.
+  // Keeps runtime stable and avoids unexpected FK errors in later writes.
+  sqlite.exec(`
+    DELETE FROM checkpoints
+    WHERE task_id NOT IN (SELECT id FROM tasks)
+       OR attempt_id NOT IN (SELECT id FROM attempts);
+
+    DELETE FROM attempts
+    WHERE task_id NOT IN (SELECT id FROM tasks);
+  `);
 }
 
 // Initialize on first import

package/src/lib/output-formatter.ts

@@ -52,6 +52,8 @@ export function formatOutput(
     return {
       formatted_data: formattedData,
       format,
+      messages,
+      status: attemptMetadata.status as any,
       attempt: {
         id: attemptMetadata.id,
         taskId: attemptMetadata.taskId,
@@ -66,6 +68,8 @@ export function formatOutput(
     return {
       formatted_data: toJson(messages),
       format: 'json',
+      messages,
+      status: attemptMetadata.status as any,
       attempt: {
         id: attemptMetadata.id,
         taskId: attemptMetadata.taskId,

package/src/lib/providers/claude-sdk-provider.ts

@@ -101,12 +101,23 @@ export class ClaudeSDKProvider extends EventEmitter implements Provider {
         canUseToolCallback: this.makeCanUseTool(attemptId),
       });
 
+      const promptPreview = prompt.substring(0, 400) + (prompt.length > 400 ? '...' : '');
+      const shouldLogFullPrompt = process.env.SDK_LOG_FULL_PROMPT === '1';
+
       log.info({
+        attemptId,
         endpoint: process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com',
-        prompt: prompt.substring(0, 200) + (prompt.length > 200 ? '...' : ''),
-        model: opts.model, cwd: opts.cwd,
+        projectPath,
+        cwd: opts.cwd,
+        model: opts.model,
+        promptLength: prompt.length,
+        promptPreview,
       }, 'SDK Query starting');
 
+      if (shouldLogFullPrompt) {
+        log.info({ attemptId, projectPath, prompt }, 'SDK Query full prompt');
+      }
+
       const response = query({ prompt, options: opts });
       session.queryRef = response;
 

package/src/lib/providers/claude-sdk-query-options-builder.ts

@@ -41,6 +41,19 @@ export interface QueryOptionsBuilderParams {
   canUseToolCallback: CanUseToolCallback;
 }
 
+type SettingSource = 'user' | 'project' | 'local';
+
+function resolveSettingSources(): SettingSource[] {
+  const allowed = new Set<SettingSource>(['user', 'project', 'local']);
+  const raw = process.env.CLAUDE_SDK_SETTING_SOURCES;
+  if (!raw || raw.trim().length === 0) return ['project'];
+  const values = raw
+    .split(',')
+    .map((value) => value.trim())
+    .filter((value): value is SettingSource => allowed.has(value as SettingSource));
+  return values.length > 0 ? values : ['project'];
+}
+
 /**
  * Build the options object for SDK query(), minus prompt.
  */
@@ -74,6 +87,7 @@ export function buildQueryOptions(params: QueryOptionsBuilderParams) {
     ...(maxTurns ? { maxTurns } : {}),
     abortController: controller,
     canUseTool: canUseToolCallback,
+    settingSources: resolveSettingSources(),
     env: buildIsolatedSubprocessEnv(model),
   };
 

package/src/types/index.ts

@@ -14,6 +14,9 @@ export type RequestMethod = 'sync' | 'queue';
 export interface FormattedResponse {
   formatted_data: string;
   format: OutputFormat;
+  // Backward-compatible fields for clients expecting parsed messages/status.
+  messages?: ClaudeOutput[];
+  status?: AttemptStatus;
   attempt: {
     id: string;
     taskId: string;

package/tsconfig.json

@@ -45,6 +45,8 @@
   "exclude": [
     "node_modules",
     "docs/**/*.ts",
-    "data/**"
+    "data/projects/**/*.ts",
+    "data/projects/**/*.tsx",
+    "data/projects/**/*.mts"
   ]
 }