@agentmeshhq/agent 0.2.1 → 0.4.0

package/dist/core/daemon.js

@@ -1,32 +1,30 @@
-import { spawn } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { getAgentState, resetAgentRestartCount, updateAgentInState } from "../config/loader.js";
+import { getAgentState, loadState, updateAgentInState } from "../config/loader.js";
 import { loadContext, loadOrCreateContext, saveContext } from "../context/index.js";
 import { renderMissingWorkdirMessage } from "./daemon/assignment-message.js";
 import { bootstrapDaemon } from "./daemon/bootstrap.js";
+import { removeClaudeMd, writeClaudeMd } from "./daemon/context-template.js";
 import { formatCrashLog } from "./daemon/crash-log.js";
-import { getNudgeMessage, getStuckDetail, isWithinNudgeWaitWindow, shouldResetRestartCount, } from "./daemon/health-policy.js";
+import { cleanupGitAuth, setupGitAuth } from "./daemon/git-auth.js";
+import { getNudgeMessage, getStuckDetail, isWithinNudgeWaitWindow, } from "./daemon/health-policy.js";
 import { writeSandboxOpencodeConfig } from "./daemon/sandbox-config.js";
 import { captureAgentChildPids, persistRunningState } from "./daemon/state.js";
 import { startTmuxRuntimeSession } from "./daemon/tmux-session.js";
-import { setupWorkspace } from "./daemon/workspace.js";
+import { configureGitIdentity, setupWorkspace, validatePushAccess } from "./daemon/workspace.js";
 import { Heartbeat } from "./heartbeat.js";
-import { handleWebSocketEvent, injectRestoredContext, injectStartupMessage } from "./injector.js";
-import { checkInbox, fetchAssignments, registerAgent } from "./registry.js";
+import { handleWebSocketEvent, injectOnboardMessage, injectRestoredContext, injectStartupMessage, } from "./injector.js";
+import { checkInbox, createSelfAssignment, fetchAssignments, fetchOnboard, fetchProjectByCode, registerAgent, } from "./registry.js";
 import { getRunnerDisplayName } from "./runner.js";
 import { DockerSandbox } from "./sandbox.js";
-import { getLatestSessionId, snapshotSessionId, waitForNewSessionId } from "./session-id.js";
-import { captureSessionContext, captureSessionOutput, createSession, destroySession, isSessionHealthy, killProcessTree, updateSessionEnvironment, } from "./tmux.js";
+import { getLatestSessionId, waitForNewSessionId } from "./session-id.js";
+import { captureSessionContext, captureSessionOutput, destroySession, isSessionHealthy, killProcessTree, updateSessionEnvironment, } from "./tmux.js";
 import { prepareOpenCodeRuntime } from "./tmux-runtime.js";
 import { checkAgentProgress, cleanupOrphanContainers, isProcessRunning, sendNudge, } from "./watchdog.js";
 import { AgentWebSocket } from "./websocket.js";
-// Maximum number of auto-restart attempts
-const MAX_RESTART_ATTEMPTS = 3;
-// Time after which restart count resets (30 minutes of stable operation)
-const RESTART_COUNT_RESET_MS = 30 * 60 * 1000;
-// Time to wait after nudging before restarting (2 minutes)
+// Time to wait after nudging before marking as stuck (2 minutes)
 const NUDGE_WAIT_MS = 2 * 60 * 1000;
 // Path to the sandbox OpenCode config (permissive permissions)
 const SANDBOX_OPENCODE_CONFIG_PATH = path.join(os.homedir(), ".agentmesh", "opencode-sandbox.json");
@@ -56,14 +54,15 @@ export class AgentDaemon {
     sandboxImage;
     sandboxCpu;
     sandboxMemory;
+    onboardData = null;
     sandbox = null;
+    projectCode;
+    projectRole;
     healthCheckInterval = null;
     // Session resume tracking
     _preStartSessionId;
     _attemptedResumeSessionId;
-    // Auto-restart tracking
-    restartCount = 0;
-    lastStableTime = null;
+    // Stuck detection tracking
     stuckSince = null;
     nudgeSentAt = null;
     constructor(options) {
@@ -80,6 +79,8 @@ export class AgentDaemon {
         this.sandboxImage = boot.sandboxImage;
         this.sandboxCpu = boot.sandboxCpu;
         this.sandboxMemory = boot.sandboxMemory;
+        this.projectCode = boot.projectCode;
+        this.projectRole = boot.projectRole;
         this.runnerConfig = boot.runnerConfig;
         const runnerName = getRunnerDisplayName(this.runnerConfig.type);
         console.log(`Runner: ${runnerName}`);
@@ -113,9 +114,6 @@ export class AgentDaemon {
                 console.log(`Cleaned up ${cleaned} orphan container(s)`);
             }
         }
-        // Reset restart count on manual start
-        this.restartCount = 0;
-        this.lastStableTime = new Date();
         // Register with hub first (needed for assignment check)
         console.log("Registering with AgentMesh hub...");
         console.log(`Existing state: ${existingState ? `agentId=${existingState.agentId}` : "none"}`);
@@ -139,8 +137,70 @@ export class AgentDaemon {
         else {
             console.log(`Registered as: ${this.agentId}`);
         }
-        // Check assignments and auto-setup workdir if needed (before creating tmux session)
-        await this.checkAssignments();
+        // Fetch onboard payload (project context, credentials, team)
+        try {
+            this.onboardData = await fetchOnboard(this.config.hubUrl, this.token);
+            if (this.onboardData) {
+                console.log(`Onboard data received${this.onboardData.project ? `: project=${this.onboardData.project.name}` : ""}`);
+                // Set up git credentials before workspace setup
+                for (const repo of this.onboardData.repos) {
+                    if (repo.credential) {
+                        const extraEnv = setupGitAuth({
+                            type: repo.credential.type,
+                            value: repo.credential.value,
+                            repoUrl: repo.url,
+                            agentName: this.agentName,
+                        });
+                        Object.assign(this.runnerConfig.env, extraEnv);
+                    }
+                }
+                // Cache onboard data locally for offline fallback
+                this.cacheOnboardData();
+            }
+        }
+        catch (error) {
+            console.log("Onboard fetch failed (non-fatal):", error.message);
+            // Try loading cached onboard data
+            this.onboardData = this.loadCachedOnboardData();
+            if (this.onboardData) {
+                console.log("Loaded cached onboard data");
+            }
+        }
+        // Resolve workdir: --project flag takes precedence, otherwise fall back to assignments
+        if (this.projectCode) {
+            await this.resolveProjectWorkdir();
+        }
+        else {
+            await this.checkAssignments();
+        }
+        // Enforce unique working directories — no two running agents may share the same workdir
+        if (this.agentConfig.workdir) {
+            const resolvedWorkdir = path.resolve(this.agentConfig.workdir);
+            const state = loadState();
+            const conflict = state.agents.find((a) => a.name !== this.agentName &&
+                a.workdir &&
+                path.resolve(a.workdir) === resolvedWorkdir &&
+                a.pid > 0 &&
+                isProcessRunning(a.pid));
+            if (conflict) {
+                throw new Error(`Workdir conflict: "${resolvedWorkdir}" is already in use by agent "${conflict.name}" (PID: ${conflict.pid}).\n` +
+                    `Each agent must have its own working directory to avoid git conflicts.\n` +
+                    `Use --workdir to specify a unique path, e.g.:\n` +
+                    `  agentmesh start --name ${this.agentName} --workdir ~/Dev/${this.assignedProject || "project"}-${this.agentName}`);
+            }
+        }
+        // Check for serve port collision
+        if (this.serveMode) {
+            const state = loadState();
+            const portConflict = state.agents.find((a) => a.name !== this.agentName &&
+                a.servePort === this.servePort &&
+                a.pid > 0 &&
+                isProcessRunning(a.pid));
+            if (portConflict) {
+                throw new Error(`Port ${this.servePort} already in use by agent "${portConflict.name}" (PID: ${portConflict.pid}).\n` +
+                    `Use --serve-port to specify a different port.`);
+            }
+        }
         // Choose runtime mode: sandbox > serve > tmux
         if (this.sandboxMode) {
             await this.startSandboxMode();
@@ -277,6 +337,20 @@ export class AgentDaemon {
             console.error("Failed to check inbox:", error);
             injectStartupMessage(this.agentName, 0);
         }
+        // Inject onboard project context
+        if (this.onboardData?.project) {
+            injectOnboardMessage(this.agentName, this.onboardData);
+        }
+        // Write persistent CLAUDE.md context file
+        if (this.onboardData && this.agentConfig.workdir) {
+            const mdPath = writeClaudeMd({
+                workdir: this.agentConfig.workdir,
+                onboard: this.onboardData,
+            });
+            if (mdPath) {
+                console.log(`✓ CLAUDE.md written: ${mdPath}`);
+            }
+        }
         // Restore context from previous session
         if (this.shouldRestoreContext && this.agentId) {
             console.log("Checking for previous context...");
@@ -368,17 +442,11 @@ Nudge agent:
         this.healthCheckInterval = setInterval(async () => {
             if (!this.isRunning)
                 return;
-            // Reset restart count after stable operation
-            if (shouldResetRestartCount(this.restartCount, this.lastStableTime, RESTART_COUNT_RESET_MS)) {
-                console.log(`[HEALTH] Agent stable for 30+ minutes, resetting restart count`);
-                this.restartCount = 0;
-                resetAgentRestartCount(this.agentName);
-            }
             // For sandbox mode, pass container name so health check looks inside container
             const containerName = this.sandboxMode ? this.sandbox?.getContainerName() : undefined;
             const health = isSessionHealthy(this.agentName, containerName);
             if (!health.healthy) {
-                // Session died - attempt restart
+                // Session died - log and mark as failed (no auto-restart)
                 await this.handleSessionDeath(health.reason || "unknown", logDir);
                 return;
             }
@@ -395,7 +463,7 @@ Nudge agent:
                 console.log(`[HEALTH] Agent is waiting for human input: ${progress.details}`);
             }
             else if (progress.status === "permission_blocked" || progress.status === "stuck") {
-                await this.handleStuckAgent(progress);
+                this.handleStuckAgent(progress);
             }
             else if (progress.status === "active") {
                 // Agent is working - reset stuck tracking
@@ -405,7 +473,6 @@ Nudge agent:
                     this.nudgeSentAt = null;
                     updateAgentInState(this.agentName, { stuckSince: undefined, status: "running" });
                 }
-                this.lastStableTime = new Date();
             }
         }, 60000); // Check every 60 seconds
     }
@@ -428,57 +495,34 @@ Nudge agent:
             agentName: this.agentName,
             agentId: this.agentId,
             reason,
-            restartCount: this.restartCount,
-            maxRestartAttempts: MAX_RESTART_ATTEMPTS,
             sandboxLabel: this.sandboxMode ? this.sandbox?.getContainerName() || "sandbox" : "none",
             workdir: this.agentConfig.workdir,
             model: this.runnerConfig.model,
             lastOutput,
         });
         fs.appendFileSync(logFile, crashLog);
-        // Save context (including session ID) before restart attempt
+        // Save context before marking as failed
         if (this.agentId) {
             this.saveAgentContext();
         }
-        // Check if we can restart
-        if (this.restartCount < MAX_RESTART_ATTEMPTS) {
-            this.restartCount++;
-            console.error(`[CRASH] Session died: ${reason}. Attempting restart (${this.restartCount}/${MAX_RESTART_ATTEMPTS})...`);
-            updateAgentInState(this.agentName, {
-                restartCount: this.restartCount,
-                lastRestartAt: timestamp,
-                status: "running",
-            });
-            try {
-                await this.restartSession();
-                console.log(`[RESTART] Agent restarted successfully`);
-                this.lastStableTime = new Date();
-            }
-            catch (error) {
-                console.error(`[RESTART] Failed to restart: ${error.message}`);
-            }
-        }
-        else {
-            // Exceeded restart limit - mark as failed
-            console.error(`[FAILED] Agent exceeded restart limit (${MAX_RESTART_ATTEMPTS}). Manual intervention required.`);
-            // Terminal bell to alert user
-            process.stdout.write("\x07");
-            updateAgentInState(this.agentName, {
-                status: "failed",
-                restartCount: this.restartCount,
-            });
-            // Stop monitoring
-            this.isRunning = false;
-            if (this.healthCheckInterval) {
-                clearInterval(this.healthCheckInterval);
-                this.healthCheckInterval = null;
-            }
+        // Mark as failed — no auto-restart, user must intervene
+        console.error(`[FAILED] Session died: ${reason}. Manual intervention required (use 'agentmesh restart ${this.agentName}').`);
+        // Terminal bell to alert user
+        process.stdout.write("\x07");
+        updateAgentInState(this.agentName, {
+            status: "failed",
+        });
+        // Stop monitoring
+        this.isRunning = false;
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
         }
     }
     /**
      * Handles stuck agent - sends nudge first, then restarts if still stuck
      */
-    async handleStuckAgent(progress) {
+    handleStuckAgent(progress) {
         const now = new Date();
         if (!this.stuckSince) {
             // First detection of stuck state
@@ -489,7 +533,7 @@ Nudge agent:
                 status: "stuck",
             });
         }
-        // Only nudge worker agents - others restart immediately
+        // Nudge worker agents — don't escalate to restart
         if (this.isWorkerAgent) {
             // If we haven't sent a nudge yet, send one
             if (!this.nudgeSentAt) {
@@ -510,124 +554,9 @@ Nudge agent:
                 // Still waiting for agent to respond to nudge
                 return;
             }
+            // Nudge grace period expired — log warning but do NOT restart
+            console.log(`[HEALTH] Agent still stuck after nudge. Manual intervention required.`);
         }
-        // Agent still stuck - trigger restart (or restart immediately if not a worker)
-        console.log(`[HEALTH] Agent still stuck${this.isWorkerAgent ? " after nudge" : ""}, triggering restart...`);
-        this.stuckSince = null;
-        this.nudgeSentAt = null;
-        await this.handleSessionDeath("stuck_after_nudge", path.join(os.homedir(), ".agentmesh", "logs"));
-    }
-    /**
-     * Restarts the agent session (sandbox or non-sandbox)
-     */
-    async restartSession() {
-        // Retrieve tracked child PIDs before destroying the session
-        const currentState = getAgentState(this.agentName);
-        const childPids = currentState?.childPids ?? [];
-        // Destroy existing session AND kill all tracked child processes
-        destroySession(this.agentName, childPids);
-        // Allow cleanup to settle before spawning a new session
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        if (this.sandboxMode && this.sandbox) {
-            // Restart sandbox container
-            const newContainerId = await this.sandbox.restart();
-            console.log(`[RESTART] New container: ${newContainerId.substring(0, 12)}`);
-            // Recreate tmux session for sandbox
-            const containerName = this.sandbox.getContainerName();
-            // Build environment args for docker exec
-            const envArgs = [];
-            const allEnv = {
-                ...this.runnerConfig.env,
-                AGENT_TOKEN: this.token,
-                AGENTMESH_AGENT_ID: this.agentId,
-            };
-            for (const [key, value] of Object.entries(allEnv)) {
-                if (value !== undefined && value !== "") {
-                    envArgs.push(`-e "${key}=${value}"`);
-                }
-            }
-            const envString = envArgs.join(" ");
-            const modelArg = this.runnerConfig.env?.OPENCODE_MODEL
-                ? ` --model ${this.runnerConfig.env.OPENCODE_MODEL}`
-                : "";
-            const dockerExecCommand = `docker exec -it ${envString} ${containerName} opencode${modelArg}`;
-            const created = createSession(this.agentName, dockerExecCommand, undefined, undefined);
-            if (!created) {
-                throw new Error("Failed to create tmux session for restarted sandbox");
-            }
-            // Track new child PIDs and update state
-            const newChildPids = captureAgentChildPids(this.agentName);
-            updateAgentInState(this.agentName, {
-                sandboxContainer: containerName,
-                childPids: newChildPids,
-            });
-            if (newChildPids.length > 0) {
-                console.log(`[RESTART] Tracking ${newChildPids.length} child PIDs: ${newChildPids.join(", ")}`);
-            }
-        }
-        else {
-            // Non-sandbox restart — load saved session ID for native resume
-            let savedSessionId;
-            let savedContext = null;
-            if (this.agentId) {
-                savedContext = loadContext(this.agentId);
-                savedSessionId = savedContext?.custom?.opencodeSessionId;
-                if (savedSessionId) {
-                    console.log(`[RESTART] Attempting to resume OpenCode session: ${savedSessionId}`);
-                }
-            }
-            const preRestartSessionId = snapshotSessionId(this.agentName);
-            const created = createSession(this.agentName, this.agentConfig.command, this.agentConfig.workdir, this.runnerConfig.env, savedSessionId);
-            if (!created) {
-                throw new Error("Failed to create tmux session");
-            }
-            // Re-inject environment
-            updateSessionEnvironment(this.agentName, {
-                AGENT_TOKEN: this.token,
-                AGENTMESH_AGENT_ID: this.agentId,
-                ...this.runnerConfig.env,
-            });
-            // Track new child PIDs
-            const newChildPids = captureAgentChildPids(this.agentName);
-            updateAgentInState(this.agentName, { childPids: newChildPids });
-            if (newChildPids.length > 0) {
-                console.log(`[RESTART] Tracking ${newChildPids.length} child PIDs: ${newChildPids.join(", ")}`);
-            }
-            // Verify native resume and fallback if needed
-            if (savedSessionId && savedContext) {
-                const newSessionId = await waitForNewSessionId(this.agentName, preRestartSessionId, 15000);
-                if (!newSessionId) {
-                    const health = isSessionHealthy(this.agentName);
-                    const currentSessionId = getLatestSessionId(this.agentName);
-                    if (!health.healthy) {
-                        console.log(`[RESTART] Fallback: OpenCode not healthy, injecting text summary.`);
-                        savedContext.custom = { ...savedContext.custom, opencodeSessionId: undefined };
-                        saveContext(savedContext);
-                        injectRestoredContext(this.agentName, savedContext);
-                    }
-                    else if (currentSessionId === savedSessionId) {
-                        console.log(`[RESTART] Resumed OpenCode session ${savedSessionId}`);
-                    }
-                    else {
-                        console.log(`[RESTART] Fallback: session not found. Injecting text summary.`);
-                        savedContext.custom = { ...savedContext.custom, opencodeSessionId: undefined };
-                        saveContext(savedContext);
-                        injectRestoredContext(this.agentName, savedContext);
-                    }
-                }
-                else if (newSessionId === savedSessionId) {
-                    console.log(`[RESTART] Resumed OpenCode session ${savedSessionId}`);
-                }
-                else {
-                    console.log(`[RESTART] Fallback: resume failed (got ${newSessionId}). Injecting text summary.`);
-                    savedContext.custom = { ...savedContext.custom, opencodeSessionId: newSessionId };
-                    saveContext(savedContext);
-                    injectRestoredContext(this.agentName, savedContext);
-                }
-            }
-        }
-        // Wait for session to be ready
-        await new Promise((resolve) => setTimeout(resolve, 2000));
     }
     async stop() {
         console.log(`\nStopping agent: ${this.agentName}`);
@@ -642,6 +571,12 @@ Nudge agent:
             console.log("Saving agent context...");
             this.saveAgentContext();
         }
+        // Clean up git credential files
+        cleanupGitAuth(this.agentName);
+        // Remove CLAUDE.md context file
+        if (this.agentConfig.workdir) {
+            removeClaudeMd(this.agentConfig.workdir);
+        }
         // Stop heartbeat
         if (this.heartbeat) {
             this.heartbeat.stop();
@@ -887,6 +822,84 @@ Logs:    docker logs ${containerName}
             console.error("Failed to save agent context:", error);
         }
     }
+    /**
+     * Resolves workdir from --project flag: looks up project by code, clones repo, self-assigns.
+     */
+    async resolveProjectWorkdir() {
+        if (!this.token || !this.agentId || !this.projectCode)
+            return;
+        console.log(`Resolving project "${this.projectCode}" from HQ...`);
+        const result = await fetchProjectByCode(this.config.hubUrl, this.token, this.projectCode);
+        if (!result) {
+            throw new Error(`Project "${this.projectCode}" not found. Check the project code in the admin UI.`);
+        }
+        const { project, repo } = result;
+        this.assignedProject = project.name;
+        console.log(`Project found: ${project.name} (${project.code})`);
+        if (!repo) {
+            throw new Error(`Project "${project.name}" has no repositories configured. Add a repo in the admin UI first.`);
+        }
+        // Compute per-agent workdir
+        let uniqueWorkdir;
+        if (project.workdir) {
+            // Sibling directory: /Users/raju/Dev/agentmesh → /Users/raju/Dev/agentmesh-agent-1
+            uniqueWorkdir = path.join(path.dirname(project.workdir), `${path.basename(project.workdir)}-${this.agentName}`);
+        }
+        else {
+            // Fallback to managed workspace path
+            uniqueWorkdir = path.join(os.homedir(), ".agentmesh", "workspaces", this.config.workspace, project.code.toLowerCase(), this.agentName);
+        }
+        console.log(`Per-agent workdir: ${uniqueWorkdir}`);
+        // Clone or pull
+        const gitDir = path.join(uniqueWorkdir, ".git");
+        if (!fs.existsSync(gitDir)) {
+            this.agentConfig.workdir = setupWorkspace({
+                workspacePath: uniqueWorkdir,
+                repoUrl: repo.url,
+                defaultBranch: repo.default_branch ?? project.default_branch ?? "main",
+                projectName: project.name,
+            });
+        }
+        else {
+            console.log(`Workspace exists, pulling latest...`);
+            try {
+                execSync("git fetch origin && git pull", {
+                    cwd: uniqueWorkdir,
+                    stdio: "pipe",
+                    timeout: 30_000,
+                });
+            }
+            catch (error) {
+                console.warn(`Could not pull latest: ${error.message}`);
+            }
+            this.agentConfig.workdir = uniqueWorkdir;
+        }
+        // Configure git identity + validate push access
+        configureGitIdentity({
+            workspacePath: uniqueWorkdir,
+            agentName: this.agentName,
+            agentDisplayName: this.onboardData?.agent.display_name ?? this.agentName,
+        });
+        validatePushAccess(uniqueWorkdir);
+        // Auto-assign the agent to the project
+        try {
+            const assignmentResult = await createSelfAssignment(this.config.hubUrl, this.token, {
+                workspace_id: this.config.workspace,
+                project_id: project.project_id,
+                agent_id: this.agentId,
+                role: this.projectRole,
+            });
+            if (assignmentResult === "existing") {
+                console.log(`Already assigned to project ${project.name}`);
+            }
+            else {
+                console.log(`Auto-assigned to project ${project.name} as ${this.projectRole}`);
+            }
+        }
+        catch (error) {
+            console.warn(`Could not auto-assign to project: ${error.message}`);
+        }
+    }
     /**
      * Fetches assignments from HQ and validates workdir setup
      * Uses project.workdir from HQ as source of truth, falls back to helpful instructions
@@ -912,31 +925,111 @@ Logs:    docker logs ${containerName}
             if (!this.agentConfig.workdir) {
                 const assignmentWithWorkdir = assignments.find((a) => a.project.workdir);
                 if (assignmentWithWorkdir?.project.workdir) {
-                    console.log(`Using workdir from project settings: ${assignmentWithWorkdir.project.workdir}`);
-                    this.agentConfig.workdir = assignmentWithWorkdir.project.workdir;
+                    // Append agent name as sibling directory to avoid shared workdir conflicts
+                    // e.g. /Users/raju/Dev/agentmesh -> /Users/raju/Dev/agentmesh-agent-1
+                    const baseWorkdir = assignmentWithWorkdir.project.workdir;
+                    const uniqueWorkdir = path.join(path.dirname(baseWorkdir), `${path.basename(baseWorkdir)}-${this.agentName}`);
+                    console.log(`Using workdir from project settings (per-agent): ${uniqueWorkdir}`);
+                    // If the unique dir doesn't exist, set up workspace (clone or pull)
+                    const gitDir = path.join(uniqueWorkdir, ".git");
+                    if (!fs.existsSync(gitDir)) {
+                        // Find repo info from assignments or onboard data for cloning
+                        const repoAssignment = assignments.find((a) => a.repo !== null);
+                        const projectDefaultBranch = assignments[0]?.project.default_branch ?? null;
+                        const projectDefaultRepoId = assignments[0]?.project.default_repo_id ?? null;
+                        const defaultRepo = projectDefaultRepoId
+                            ? this.onboardData?.repos.find((r) => r.repo_id === projectDefaultRepoId)
+                            : null;
+                        const fallbackRepo = defaultRepo ?? this.onboardData?.repos[0];
+                        const repoInfo = repoAssignment?.repo ??
+                            (fallbackRepo
+                                ? {
+                                    url: fallbackRepo.url,
+                                    default_branch: projectDefaultBranch ?? fallbackRepo.default_branch ?? "main",
+                                    full_name: fallbackRepo.full_name,
+                                }
+                                : null);
+                        const projectName = repoAssignment?.project.name ?? assignments[0]?.project.name ?? "unknown";
+                        if (repoInfo) {
+                            this.agentConfig.workdir = setupWorkspace({
+                                workspacePath: uniqueWorkdir,
+                                repoUrl: repoInfo.url,
+                                defaultBranch: repoInfo.default_branch,
+                                projectName,
+                            });
+                            configureGitIdentity({
+                                workspacePath: uniqueWorkdir,
+                                agentName: this.agentName,
+                                agentDisplayName: this.onboardData?.agent.display_name ?? this.agentName,
+                            });
+                            validatePushAccess(uniqueWorkdir);
+                        }
+                        else {
+                            // Genuinely no repo info — just create the directory
+                            fs.mkdirSync(uniqueWorkdir, { recursive: true });
+                            this.agentConfig.workdir = uniqueWorkdir;
+                        }
+                    }
+                    else {
+                        // Directory exists with .git — pull latest
+                        console.log(`Workspace exists, pulling latest...`);
+                        try {
+                            execSync("git fetch origin && git pull", {
+                                cwd: uniqueWorkdir,
+                                stdio: "pipe",
+                                timeout: 30_000,
+                            });
+                        }
+                        catch (error) {
+                            console.warn(`Could not pull latest: ${error.message}`);
+                        }
+                        this.agentConfig.workdir = uniqueWorkdir;
+                    }
                     return;
                 }
-                // No project.workdir set, check if we have a repo assignment
+                // No project.workdir set, check if we have a repo assignment or onboard repo
                 const repoAssignment = assignments.find((a) => a.repo !== null);
-                if (repoAssignment) {
-                    const repo = repoAssignment.repo;
-                    const expandedPath = path.join(os.homedir(), ".agentmesh", "workspaces", this.config.workspace, repoAssignment.project.code.toLowerCase(), this.agentName);
-                    const suggestedPath = `~/.agentmesh/workspaces/${this.config.workspace}/${repoAssignment.project.code.toLowerCase()}/${this.agentName}`;
+                const projectDefaultBranch = assignments[0]?.project.default_branch ?? null;
+                const projectDefaultRepoId = assignments[0]?.project.default_repo_id ?? null;
+                const defaultRepo = projectDefaultRepoId
+                    ? this.onboardData?.repos.find((r) => r.repo_id === projectDefaultRepoId)
+                    : null;
+                const fallbackRepo = defaultRepo ?? this.onboardData?.repos[0];
+                const repoInfo = repoAssignment?.repo ??
+                    (fallbackRepo
+                        ? {
+                            url: fallbackRepo.url,
+                            default_branch: projectDefaultBranch ?? fallbackRepo.default_branch ?? "main",
+                            full_name: fallbackRepo.full_name,
+                        }
+                        : null);
+                const projectCode = repoAssignment?.project.code ?? assignments[0]?.project.code ?? "unknown";
+                const projectName = repoAssignment?.project.name ?? assignments[0]?.project.name ?? "unknown";
+                if (repoInfo) {
+                    const expandedPath = path.join(os.homedir(), ".agentmesh", "workspaces", this.config.workspace, projectCode.toLowerCase(), this.agentName);
+                    const suggestedPath = `~/.agentmesh/workspaces/${this.config.workspace}/${projectCode.toLowerCase()}/${this.agentName}`;
                     // If --auto-setup is enabled, automatically clone the repo
                     if (this.autoSetup) {
                         this.agentConfig.workdir = setupWorkspace({
                             workspacePath: expandedPath,
-                            repoUrl: repo.url,
-                            defaultBranch: repo.default_branch,
-                            projectName: repoAssignment.project.name,
+                            repoUrl: repoInfo.url,
+                            defaultBranch: repoInfo.default_branch,
+                            projectName,
+                        });
+                        // Configure git identity and validate push access
+                        configureGitIdentity({
+                            workspacePath: expandedPath,
+                            agentName: this.agentName,
+                            agentDisplayName: this.onboardData?.agent.display_name ?? this.agentName,
                         });
+                        validatePushAccess(expandedPath);
                         return;
                     }
                     console.error(renderMissingWorkdirMessage({
-                        projectName: repoAssignment.project.name,
-                        repoFullName: repo.full_name,
-                        repoUrl: repo.url,
-                        defaultBranch: repo.default_branch,
+                        projectName,
+                        repoFullName: repoInfo.full_name,
+                        repoUrl: repoInfo.url,
+                        defaultBranch: repoInfo.default_branch,
                         suggestedPath,
                         agentName: this.agentName,
                     }));
@@ -962,5 +1055,50 @@ Logs:    docker logs ${containerName}
         });
         console.log(`Updated sandbox OpenCode config: ${SANDBOX_OPENCODE_CONFIG_PATH}`);
     }
+    /**
+     * Caches onboard data to disk for offline fallback
+     */
+    cacheOnboardData() {
+        if (!this.onboardData || !this.agentId)
+            return;
+        try {
+            const cacheDir = path.join(os.homedir(), ".agentmesh", "context");
+            if (!fs.existsSync(cacheDir)) {
+                fs.mkdirSync(cacheDir, { recursive: true });
+            }
+            // Strip credential values before caching
+            const cacheData = {
+                ...this.onboardData,
+                repos: this.onboardData.repos.map((r) => ({
+                    ...r,
+                    credential: r.credential ? { type: r.credential.type, value: "***" } : null,
+                })),
+                cached_at: new Date().toISOString(),
+            };
+            const cachePath = path.join(cacheDir, `${this.agentId}-onboard.json`);
+            fs.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2));
+        }
+        catch (error) {
+            console.log("Failed to cache onboard data:", error.message);
+        }
+    }
+    /**
+     * Loads cached onboard data from disk (without credentials)
+     */
+    loadCachedOnboardData() {
+        if (!this.agentId)
+            return null;
+        try {
+            const cachePath = path.join(os.homedir(), ".agentmesh", "context", `${this.agentId}-onboard.json`);
+            if (!fs.existsSync(cachePath))
+                return null;
+            const raw = fs.readFileSync(cachePath, "utf-8");
+            const data = JSON.parse(raw);
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
 }
 //# sourceMappingURL=daemon.js.map