Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
fix(workspace): restore snapshots over empty dirs and preserve git-tracked excluded paths (#989)
crispinhu274bcd9fbb04f3
diff --git a/internal/engine/browser.go b/internal/engine/browser.goindex ff8a8566..f9b34be0 100644--- a/internal/engine/browser.go+++ b/internal/engine/browser.go@@ -88,6 +88,9 @@ func (e *Engine) ensureRunBrowser(ctx context.Context, run domain.Run) error {if _, err := e.PrepareConversationWorkspace(ctx, run.ID, token); err != nil {return err}+ if latest, ok := e.repo.RunState(run.ID); ok {+ run = latest+ }ctx = WithConversationWorkspaceToken(ctx, token, run.ID)}env, err := e.acquireConversationEnvironment(ctx, run)diff --git a/internal/engine/conversation_workspace.go b/internal/engine/conversation_workspace.goindex 59a6db63..e3b50ff7 100644--- a/internal/engine/conversation_workspace.go+++ b/internal/engine/conversation_workspace.go@@ -12,6 +12,7 @@ import ("agentflow/internal/domain""agentflow/internal/gitwork""agentflow/internal/repo"+ "agentflow/internal/runtime")const ConversationWorkspaceIdleTTL = time.Hour@@ -285,10 +286,24 @@ func (e *Engine) ensureConversationWorkspace(ctx context.Context, id, token stri}root := e.sandboxes.RunWorkspace(id)if info, statErr := os.Lstat(root); statErr == nil && info.IsDir() && !e.foreignWorkspaceBind(run) {- if err = e.verifyStoredCheckpoint(ctx, id); err != nil {+ hasContent, contentErr := runtime.WorkspaceDirHasContent(root)+ if contentErr != nil {+ return contentErr+ }+ if hasContent {+ if err = e.verifyStoredCheckpoint(ctx, id); err != nil {+ return err+ }+ return e.repo.RestoreCheckpointWorkspaceBinding(id, token, e.workspaceHost, e.sandboxes.Root(), time.Now().UTC())+ }+ // An empty or .agentflow-only directory created before restoration+ // holds no user files; tear down any container bound to its old inode+ // so restoreConversationCheckpoint can atomically replace it and the+ // next container bind sees the restored files.+ if err = e.releaseRunEnvironment(id, false); err != nil {return err}- return e.repo.RestoreCheckpointWorkspaceBinding(id, token, e.workspaceHost, e.sandboxes.Root(), time.Now().UTC())+ e.sandboxes.DiscardRunContainer(ctx, id)}if err = e.restoreConversationCheckpoint(ctx, run, root); err != nil {return errdiff --git a/internal/engine/conversation_workspace_test.go b/internal/engine/conversation_workspace_test.goindex a8212211..e1ff3113 100644--- a/internal/engine/conversation_workspace_test.go+++ b/internal/engine/conversation_workspace_test.go@@ -504,3 +504,107 @@ func TestConversationWorkspaceRetriesFailedSaveBeforeIdleReclamation(t *testing.t.Fatal("retry reclaimed active conversation files", err)}}++func TestConversationWorkspaceRestoresOverPrecreatedEmptyAndAgentFlowDirectory(t *testing.T) {+ t.Parallel()+ for _, mode := range []string{"empty", "agentflow-only"} {+ t.Run(mode, func(t *testing.T) {+ e, id := checkpointFixture(t)+ e.reconcileTerminalWorkspaceCleanup()+ r, _ := e.repo.RunState(id)+ if r.WorkspaceCleanedAt.IsZero() {+ t.Fatal("precondition: workspace not reclaimed")+ }+ root := e.RunWorkspace(id)+ if err := os.MkdirAll(root, 0o700); err != nil {+ t.Fatal(err)+ }+ if mode == "agentflow-only" {+ if err := os.MkdirAll(filepath.Join(root, ".agentflow", "hooks"), 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(root, ".agentflow", "hooks", "pre.json"), []byte("{}"), 0o600); err != nil {+ t.Fatal(err)+ }+ }++ token, err := e.BeginConversationWorkspaceUse(id)+ if err != nil {+ t.Fatal(err)+ }+ if err := e.EnsureConversationWorkspace(context.Background(), id, token); err != nil {+ t.Fatal(err)+ }+ defer e.EndConversationWorkspaceUse(context.Background(), id, token)++ body, err := os.ReadFile(filepath.Join(root, "README.md"))+ if err != nil || string(body) != "uncommitted" {+ t.Fatalf("snapshot not unpacked over %s directory: %q (%v)", mode, body, err)+ }+ r, _ = e.repo.RunState(id)+ if !r.WorkspaceCleanedAt.IsZero() {+ t.Fatal("cleanup marker not cleared after restore")+ }+ })+ }+}++func TestAcquireConversationEnvironmentRefusesUnrestoredReclaimedWorkspace(t *testing.T) {+ t.Parallel()+ e, id := checkpointFixture(t)+ e.reconcileTerminalWorkspaceCleanup()+ if _, err := os.Lstat(e.RunWorkspace(id)); !os.IsNotExist(err) {+ t.Fatalf("precondition: reclaimed dir still exists: %v", err)+ }+ if _, err := e.EnsureWorkspaceReady(context.Background(), id); err == nil {+ t.Fatal("EnsureWorkspaceReady succeeded on unrestored reclaimed workspace")+ }+ if _, err := os.Lstat(e.RunWorkspace(id)); !os.IsNotExist(err) {+ t.Fatalf("EnsureWorkspaceReady pre-created empty dir before snapshot restore: %v", err)+ }+}++func TestEnsureRunBrowserRestoresReclaimedWorkspaceWithStaleRun(t *testing.T) {+ bin := t.TempDir()+ chromium := filepath.Join(bin, "chromium")+ script := `#!/bin/sh+profile=+for arg in "$@"; do+ case "$arg" in --user-data-dir=*) profile="${arg#*=}";; esac+done+mkdir -p "$profile"+printf '9224\n/devtools/browser/stale\n' > "$profile/DevToolsActivePort"+exec sleep 30+`+ if err := os.WriteFile(chromium, []byte(script), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(bin, "playwright-mcp"), []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {+ t.Fatal(err)+ }+ t.Setenv("AGENTFLOW_CHROMIUM", chromium)+ t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))++ e, id := checkpointFixture(t)+ t.Cleanup(func() {+ _, _ = runtime.HandleBrowser(context.Background(), id, domain.BrowserRequest{Operation: "stop"})+ _ = e.releaseRunEnvironment(id, true)+ })+ e.reconcileTerminalWorkspaceCleanup()+ staleRun, ok := e.repo.RunState(id)+ if !ok || staleRun.WorkspaceCleanedAt.IsZero() {+ t.Fatalf("precondition: expected reclaimed run, got %+v (ok=%v)", staleRun, ok)+ }++ if err := e.ensureRunBrowser(context.Background(), staleRun); err != nil {+ t.Fatalf("ensureRunBrowser with stale reclaimed run failed: %v", err)+ }+ body, err := os.ReadFile(filepath.Join(e.RunWorkspace(id), "README.md"))+ if err != nil || string(body) != "uncommitted" {+ t.Fatalf("restored README.md = %q (%v)", body, err)+ }+ fresh, _ := e.repo.RunState(id)+ if !fresh.WorkspaceCleanedAt.IsZero() {+ t.Fatal("cleanup marker not cleared after ensureRunBrowser restore")+ }+}diff --git a/internal/engine/workspace_checkpoint_stream.go b/internal/engine/workspace_checkpoint_stream.goindex 231019ad..df718309 100644--- a/internal/engine/workspace_checkpoint_stream.go+++ b/internal/engine/workspace_checkpoint_stream.go@@ -38,7 +38,7 @@ func (e *Engine) saveConversationWorkspace(ctx context.Context, run domain.Run,if reason != "" {return fmt.Errorf("%s", reason)}- err = runtime.CreateWorkspaceCheckpointTo(root, workspaceCheckpointContextWriter{ctx, file})+ err = runtime.CreateWorkspaceCheckpointToContext(ctx, root, workspaceCheckpointContextWriter{ctx, file})if os.IsNotExist(err) && run.WorkspaceHost == "" {if err = file.Truncate(0); err != nil {return err@@ -216,6 +216,14 @@ func (e *Engine) restoreOrReuseRemoteConversationCheckpoint(ctx context.Context,}} else {err = workspaceCheckpointResponseError(probe)+ if err == nil {+ var status struct {+ Empty bool `json:"empty"`+ }+ if len(probe.Payload) > 0 && json.Unmarshal(probe.Payload, &status) == nil && status.Empty {+ err = os.ErrNotExist+ }+ }}if err == nil {return e.verifyStoredCheckpoint(ctx, run.ID)diff --git a/internal/engine/workspace_checkpoint_transport.go b/internal/engine/workspace_checkpoint_transport.goindex 6b94aa7e..3e21cb7f 100644--- a/internal/engine/workspace_checkpoint_transport.go+++ b/internal/engine/workspace_checkpoint_transport.go@@ -8,6 +8,7 @@ import ("fmt""io""net/http"+ "os""strings""time"@@ -238,7 +239,14 @@ func (e *Engine) HandleWorkspaceCheckpoint(w http.ResponseWriter, r *http.Requesresult = runtime.WorkspaceCheckpointStatus(root)}} else if transfer {- result = e.checkpointTransfers.Handle(r.Context(), root, request)+ if request.Operation == domain.RunnerWorkspaceOperationCheckpointCommit {+ if err := e.discardEmptyWorkspaceContainer(r.Context(), run.ID, root); err != nil {+ result.Error = err.Error()+ }+ }+ if result.Error == "" {+ result = e.checkpointTransfers.Handle(r.Context(), root, request)+ }} else if request.Operation == domain.RunnerWorkspaceOperationReclaim {meta, saved := e.repo.WorkspaceCheckpoint(run.ID)if !saved || meta.SavedAt == nil || meta.Error != "" || run.WorkspaceCleanedAt.IsZero() || request.CheckpointLease == "" || meta.LeaseToken != request.CheckpointLease || meta.LeaseUntil == nil || !meta.LeaseUntil.After(time.Now()) {@@ -258,12 +266,14 @@ func (e *Engine) HandleWorkspaceCheckpoint(w http.ResponseWriter, r *http.Requesresult.Payload, _ = json.Marshal(map[string]any{"restoredArtifacts": restored})}} else if request.Operation == domain.RunnerWorkspaceOperationCheckpoint {- archive, err := runtime.CreateWorkspaceCheckpoint(root)+ archive, err := runtime.CreateWorkspaceCheckpointContext(r.Context(), root)if err != nil {result.Error = err.Error()} else {result.Payload, _ = json.Marshal(map[string]any{"checkpoint": archive})}+ } else if err := e.discardEmptyWorkspaceContainer(r.Context(), run.ID, root); err != nil {+ result.Error = err.Error()} else if err := runtime.RestoreWorkspaceCheckpoint(root, request.Checkpoint); err != nil {result.Error = err.Error()} else {@@ -273,3 +283,19 @@ func (e *Engine) HandleWorkspaceCheckpoint(w http.ResponseWriter, r *http.Requesw.Header().Set("Content-Type", "application/json")_ = json.NewEncoder(w).Encode(result)}++func (e *Engine) discardEmptyWorkspaceContainer(ctx context.Context, runID, root string) error {+ info, err := os.Lstat(root)+ if err != nil || !info.IsDir() {+ return nil+ }+ hasContent, err := runtime.WorkspaceDirHasContent(root)+ if err != nil || hasContent {+ return nil+ }+ if err := e.releaseRunEnvironment(runID, false); err != nil {+ return err+ }+ e.sandboxes.DiscardRunContainer(ctx, runID)+ return nil+}diff --git a/internal/engine/workspace_preparation.go b/internal/engine/workspace_preparation.goindex 32303593..ba6843d3 100644--- a/internal/engine/workspace_preparation.go+++ b/internal/engine/workspace_preparation.go@@ -32,9 +32,17 @@ func (e *Engine) workspaceSandboxProfile(run domain.Run) (domain.SandboxProfile,// lease. The workspace-use lease fences cleanup; the sandbox's workspace flock// fences another process. An active local scheduler shares its existing handle.func (e *Engine) acquireConversationEnvironment(ctx context.Context, run domain.Run) (*runEnvironment, error) {+ if latest, ok := e.repo.RunState(run.ID); ok {+ run = latest+ }if e.foreignWorkspaceBind(run) || e.defaultExecutionRunner(run) != "" {return nil, fmt.Errorf("工作区属于其他执行实例")}+ if !run.WorkspaceCleanedAt.IsZero() {+ if meta, saved := e.repo.WorkspaceCheckpoint(run.ID); saved && meta.SavedAt != nil {+ return nil, fmt.Errorf("工作区已回收,请先恢复快照后再打开环境")+ }+ }e.runEnvMu.Lock()defer e.runEnvMu.Unlock()if env := e.runEnvs[run.ID]; env != nil {@@ -333,6 +341,9 @@ func (e *Engine) PrepareNodeWorkspace(ctx context.Context, run domain.Run, env *// contract as SOP execution. The pool owns the PTY, the Engine owns the sandbox.func (e *Engine) HandleWorkspaceTerminal(ctx context.Context, id string, pool *runtime.TerminalPool, scope string, req domain.WorkspaceTerminalRequest, actorID int64) (runtime.TerminalResult, error) {if req.Operation == "open" {+ if err := e.RestoreConversationWorkspaceIfNeeded(ctx, id); err != nil {+ return runtime.TerminalResult{}, err+ }if _, err := e.EnsureWorkspaceReady(ctx, id); err != nil {return runtime.TerminalResult{}, err}diff --git a/internal/engine/workspace_restore_retry_test.go b/internal/engine/workspace_restore_retry_test.goindex 1b2f8e56..3a1afb54 100644--- a/internal/engine/workspace_restore_retry_test.go+++ b/internal/engine/workspace_restore_retry_test.go@@ -263,3 +263,70 @@ func TestConversationWorkspaceRunnerReusesSurvivingDirectory(t *testing.T) {})}}++func TestConversationWorkspaceRemoteAndRunnerRestoreOverEmptyDirectory(t *testing.T) {+ t.Parallel()+ for _, target := range []string{"runner-empty", "runner-agentflow-only", "foreign-worker-empty", "foreign-worker-agentflow-only"} {+ t.Run(target, func(t *testing.T) {+ worker, controller, id := remoteWorkspaceRestoreFixture(t, "sqlite")+ root := worker.RunWorkspace(id)+ if err := os.MkdirAll(root, 0o700); err != nil {+ t.Fatal(err)+ }+ if strings.HasSuffix(target, "agentflow-only") {+ if err := os.MkdirAll(filepath.Join(root, ".agentflow", "hooks"), 0o700); err != nil {+ t.Fatal(err)+ }+ }+ restores := 0+ if strings.HasPrefix(target, "runner-") {+ run, _ := worker.repo.RunState(id)+ run.ExecutionContext.ExecutionMode = domain.ExecutionModeRunner+ run.ExecutionContext.ExecutionRunnerID = "restore-runner"+ if err := worker.repo.PutRun(run); err != nil {+ t.Fatal(err)+ }+ controller.WorkspaceCheckpointTransport = func(_ context.Context, _ domain.Run, request domain.RunnerWorkspaceRequest) (domain.RunnerWorkspaceResponse, error) {+ if request.Operation == domain.RunnerWorkspaceOperationCheckpointStatus {+ return runtime.WorkspaceCheckpointStatus(root), nil+ }+ if request.Operation == domain.RunnerWorkspaceOperationRestore {+ restores+++ if err := runtime.RestoreWorkspaceCheckpoint(root, request.Checkpoint); err != nil {+ return domain.RunnerWorkspaceResponse{Error: err.Error()}, nil+ }+ return domain.RunnerWorkspaceResponse{Payload: json.RawMessage(`{"restored":true}`)}, nil+ }+ return domain.RunnerWorkspaceResponse{Error: "unexpected operation " + request.Operation}, nil+ }+ } else {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.Method == http.MethodPost {+ var body domain.RunnerWorkspaceRequest+ raw, _ := io.ReadAll(r.Body)+ _ = json.Unmarshal(raw, &body)+ if body.Operation == domain.RunnerWorkspaceOperationRestore || body.Operation == domain.RunnerWorkspaceOperationCheckpointCommit {+ restores+++ }+ r.Body = io.NopCloser(bytes.NewReader(raw))+ }+ worker.HandleWorkspaceCheckpoint(w, r)+ }))+ defer server.Close()+ if err := worker.repo.HeartbeatEngineInstance(repo.EngineInstance{InstanceID: worker.workspaceHost, Role: "worker", WorkspaceHost: worker.workspaceHost, ControlURL: server.URL}, time.Minute); err != nil {+ t.Fatal(err)+ }+ }+ if err := controller.RestoreConversationWorkspaceIfNeeded(context.Background(), id); err != nil {+ t.Fatal(err)+ }+ if restores != 1 {+ t.Fatalf("restores = %d, want 1", restores)+ }+ body, err := os.ReadFile(filepath.Join(root, "README.md"))+ if err != nil || string(body) != "saved changes" {+ t.Fatalf("remote restore lost files: %q (%v)", body, err)+ }+ })+ }+}diff --git a/internal/runner/workspace.go b/internal/runner/workspace.goindex 04d2fb42..6e24221f 100644--- a/internal/runner/workspace.go+++ b/internal/runner/workspace.go@@ -143,6 +143,11 @@ func (d *Daemon) readRunnerWorkspace(ctx context.Context, request domain.RunnerWreturn workspaceBusyResponse("workspace is still in use")}defer gate.Unlock()+ if request.Operation == domain.RunnerWorkspaceOperationCheckpointCommit {+ if hasContent, err := runtime.WorkspaceDirHasContent(root); err == nil && !hasContent {+ d.closeRunSandboxes(ctx, request.RunID)+ }+ }}return d.checkpointTransfers.Handle(ctx, root, request)}@@ -155,6 +160,9 @@ func (d *Daemon) readRunnerWorkspace(ctx context.Context, request domain.RunnerWreturn workspaceBusyResponse("workspace is still in use")}defer gate.Unlock()+ if hasContent, err := runtime.WorkspaceDirHasContent(root); err == nil && !hasContent {+ d.closeRunSandboxes(ctx, request.RunID)+ }if err := runtime.RestoreWorkspaceCheckpoint(root, request.Checkpoint); err != nil {return runnerWorkspaceError(err)}@@ -213,7 +221,7 @@ func (d *Daemon) readRunnerWorkspace(ctx context.Context, request domain.RunnerWreturn workspaceBusyResponse("workspace is still in use")}defer gate.Unlock()- archive, err := runtime.CreateWorkspaceCheckpoint(root)+ archive, err := runtime.CreateWorkspaceCheckpointContext(ctx, root)if err != nil {return runnerWorkspaceError(err)}diff --git a/internal/runner/workspace_preparation_test.go b/internal/runner/workspace_preparation_test.goindex 2a38f018..f565f5f7 100644--- a/internal/runner/workspace_preparation_test.go+++ b/internal/runner/workspace_preparation_test.go@@ -648,3 +648,43 @@ func TestRunnerConcurrentEditSharesOnlyTheAgentFence(t *testing.T) {}gate.Unlock()}++func TestRunnerCheckpointStatusAndRestoreOverEmptyDirectory(t *testing.T) {+ d, request, root := runnerPreparationFixture(t)+ defer d.closeAllRunSandboxes(context.Background())++ src := t.TempDir()+ if err := os.WriteFile(filepath.Join(src, "restored.txt"), []byte("from-checkpoint"), 0o600); err != nil {+ t.Fatal(err)+ }+ archive, err := runtime.CreateWorkspaceCheckpoint(src)+ if err != nil {+ t.Fatal(err)+ }++ if err := os.MkdirAll(filepath.Join(root, ".agentflow", "hooks"), 0o700); err != nil {+ t.Fatal(err)+ }+ status := d.readRunnerWorkspace(context.Background(), domain.RunnerWorkspaceRequest{+ RunID: request.RunID,+ WorkspaceLayout: domain.RunnerWorkspaceLayoutShared,+ Operation: domain.RunnerWorkspaceOperationCheckpointStatus,+ })+ if status.Status != 200 || !strings.Contains(string(status.Payload), `"empty":true`) {+ t.Fatalf("status = %+v payload=%s", status, status.Payload)+ }++ restored := d.readRunnerWorkspace(context.Background(), domain.RunnerWorkspaceRequest{+ RunID: request.RunID,+ WorkspaceLayout: domain.RunnerWorkspaceLayoutShared,+ Operation: domain.RunnerWorkspaceOperationRestore,+ Checkpoint: archive,+ })+ if restored.Status != 200 || restored.Error != "" {+ t.Fatalf("restore = %+v", restored)+ }+ got, err := os.ReadFile(filepath.Join(root, "restored.txt"))+ if err != nil || string(got) != "from-checkpoint" {+ t.Fatalf("restored.txt = %q (%v)", got, err)+ }+}diff --git a/internal/runtime/executor_cases_test.go b/internal/runtime/executor_cases_test.goindex 2fb2962e..79819b72 100644--- a/internal/runtime/executor_cases_test.go+++ b/internal/runtime/executor_cases_test.go@@ -175,8 +175,16 @@ func TestCheckpointValidationStatusAndBounds(t *testing.T) {t.Fatal("invalid checkpoint accepted")}root := t.TempDir()- if response := WorkspaceCheckpointStatus(root); response.Status != 200 {- t.Fatalf("status=%+v", response)+ if response := WorkspaceCheckpointStatus(root); response.Status != 200 || !strings.Contains(string(response.Payload), `"empty":true`) {+ t.Fatalf("empty status=%+v payload=%s", response, response.Payload)+ }+ _ = os.MkdirAll(filepath.Join(root, ".agentflow", "hooks"), 0o700)+ if response := WorkspaceCheckpointStatus(root); response.Status != 200 || !strings.Contains(string(response.Payload), `"empty":true`) {+ t.Fatalf("runtime-only status=%+v payload=%s", response, response.Payload)+ }+ _ = os.WriteFile(filepath.Join(root, "real.txt"), []byte("x"), 0o600)+ if response := WorkspaceCheckpointStatus(root); response.Status != 200 || !strings.Contains(string(response.Payload), `"empty":false`) {+ t.Fatalf("populated status=%+v payload=%s", response, response.Payload)}missing := filepath.Join(root, "missing")if response := WorkspaceCheckpointStatus(missing); response.Status != 404 {diff --git a/internal/runtime/workspace_checkpoint.go b/internal/runtime/workspace_checkpoint.goindex 408eb6aa..78d607d6 100644--- a/internal/runtime/workspace_checkpoint.go+++ b/internal/runtime/workspace_checkpoint.go@@ -4,13 +4,17 @@ import ("archive/tar""bytes""compress/gzip"+ "context""fmt""io""io/fs""os"+ "os/exec"+ pathpkg "path""path/filepath""slices""strings"+ "time")// Checkpoints exclude execution credentials and reproducible dependency caches.@@ -22,15 +26,44 @@ const WorkspaceCheckpointMaxBytes = 12 << 20const WorkspaceCheckpointArchiveMaxBytes = 512 << 20const WorkspaceCheckpointChunkBytes = 4 << 20const workspaceCheckpointExpandedMax = 2 << 30+const checkpointGitOutputMaxBytes = 16 << 20++var checkpointGitIndexTimeout = 15 * time.Second// checkpointRestoreExcludedNames are path components a restored archive must-// never contain.-var checkpointRestoreExcludedNames = []string{".agentflow", "node_modules", ".cache", "__pycache__"}+// never contain (and never capture, even if committed inside a repository).+var checkpointRestoreExcludedNames = []string{".agentflow"}++// checkpointExcludedNames are skipped when capturing unless preserved as+// Git-tracked repository files (except checkpointRestoreExcludedNames).+var checkpointExcludedNames = append(slices.Clone(checkpointRestoreExcludedNames), "node_modules", ".cache", "__pycache__", ".zvec-grep")-// checkpointExcludedNames are skipped when capturing. Older valid archives can-// contain .zvec-grep, so it is excluded from new captures only and must not-// make those existing snapshots unrestorable.-var checkpointExcludedNames = append(slices.Clone(checkpointRestoreExcludedNames), ".zvec-grep")+// WorkspaceDirHasContent reports whether root already holds user or repository+// files on disk. An empty directory or one containing only the platform's+// runtime .agentflow directory holds no user workspace data.+func WorkspaceDirHasContent(root string) (bool, error) {+ info, err := os.Lstat(root)+ if os.IsNotExist(err) {+ return false, nil+ }+ if err != nil {+ return false, err+ }+ if !info.IsDir() {+ return false, fmt.Errorf("workspace is not a directory")+ }+ entries, err := os.ReadDir(root)+ if err != nil {+ return false, err+ }+ for _, entry := range entries {+ if entry.Name() == ".agentflow" && entry.IsDir() {+ continue+ }+ return true, nil+ }+ return false, nil+}func checkpointPathHasComponent(path string, names []string) bool {for _, part := range strings.Split(filepath.ToSlash(path), "/") {@@ -57,8 +90,12 @@ func checkpointPath(path string) (string, error) {return clean, nil}func CreateWorkspaceCheckpoint(root string) ([]byte, error) {+ return CreateWorkspaceCheckpointContext(context.Background(), root)+}++func CreateWorkspaceCheckpointContext(ctx context.Context, root string) ([]byte, error) {var buffer bytes.Buffer- err := CreateWorkspaceCheckpointTo(root, &checkpointBoundedWriter{writer: &buffer, left: WorkspaceCheckpointMaxBytes})+ err := CreateWorkspaceCheckpointToContext(ctx, root, &checkpointBoundedWriter{writer: &buffer, left: WorkspaceCheckpointMaxBytes})if err != nil {return nil, err}@@ -66,6 +103,13 @@ func CreateWorkspaceCheckpoint(root string) ([]byte, error) {}func CreateWorkspaceCheckpointTo(root string, destination io.Writer) error {+ return CreateWorkspaceCheckpointToContext(context.Background(), root, destination)+}++func CreateWorkspaceCheckpointToContext(ctx context.Context, root string, destination io.Writer) error {+ if ctx == nil {+ ctx = context.Background()+ }info, err := os.Lstat(root)if err != nil {return err@@ -85,18 +129,24 @@ func CreateWorkspaceCheckpointTo(root string, destination io.Writer) error {writer := tar.NewWriter(&checkpointBoundedWriter{writer: zipped, left: workspaceCheckpointExpandedMax})var expanded int64entries := 0+ tracker := &checkpointGitTracker{ctx: ctx, root: root, base: base}err = fs.WalkDir(base.FS(), ".", func(path string, entry fs.DirEntry, walkErr error) error {if walkErr != nil {return walkErr}+ if ctxErr := ctx.Err(); ctxErr != nil {+ return ctxErr+ }if path == "." {return nil}if checkpointExcluded(path) {- if entry.IsDir() {- return fs.SkipDir+ if checkpointRestoreExcluded(path) || !tracker.keeps(path, entry.IsDir()) {+ if entry.IsDir() {+ return fs.SkipDir+ }+ return nil}- return nil}entries++if entries > 100000 {@@ -184,6 +234,232 @@ func copyCheckpointFile(base *os.Root, writer io.Writer, path string, size int64return closeErr}+type checkpointGitIndex struct {+ files map[string]bool+ dirs map[string]bool+}++type checkpointLimitedBuffer struct {+ buf bytes.Buffer+ limit int+ overflow bool+}++func (b *checkpointLimitedBuffer) Write(p []byte) (int, error) {+ if b.buf.Len()+len(p) > b.limit {+ b.overflow = true+ return 0, fmt.Errorf("git output exceeds limit")+ }+ return b.buf.Write(p)+}++// checkpointGitTracker lazily indexes Git-tracked files matching+// checkpointExcludedNames per repository inside root, so tracked files (such+// as committed web/*/node_modules assets) survive snapshots while untracked+// dependency installs are still skipped.+type checkpointGitTracker struct {+ ctx context.Context+ root string+ base *os.Root+ repoFlags map[string]bool+ indexes map[string]*checkpointGitIndex+}++func (t *checkpointGitTracker) keeps(rel string, isDir bool) bool {+ repoRel, ok := t.findRepo(pathpkg.Dir(filepath.ToSlash(rel)))+ if !ok {+ return false+ }+ idx := t.repoIndex(repoRel)+ if idx == nil || len(idx.files) == 0 {+ return false+ }+ repoFile := filepath.ToSlash(rel)+ if repoRel != "." {+ repoFile = strings.TrimPrefix(repoFile, repoRel+"/")+ }+ if isDir {+ return idx.dirs[repoFile] || idx.files[repoFile]+ }+ return idx.files[repoFile]+}++func (t *checkpointGitTracker) findRepo(startDir string) (string, bool) {+ if t.repoFlags == nil {+ t.repoFlags = map[string]bool{}+ }+ for dir := pathpkg.Clean(startDir); ; dir = pathpkg.Dir(dir) {+ if isRepo, checked := t.repoFlags[dir]; checked {+ if isRepo {+ return dir, true+ }+ } else {+ gitPath := ".git"+ if dir != "." {+ gitPath = pathpkg.Join(dir, ".git")+ }+ // Submodules and linked worktrees use a regular .git file (already+ // rejected when referencing external metadata), so only+ // self-contained .git directories are indexed here.+ info, err := t.base.Lstat(filepath.FromSlash(gitPath))+ isRepo = err == nil && info.IsDir()+ t.repoFlags[dir] = isRepo+ if isRepo {+ return dir, true+ }+ }+ if dir == "." || dir == "/" || dir == "" {+ return "", false+ }+ }+}++func (t *checkpointGitTracker) repoIndex(repoRel string) *checkpointGitIndex {+ if t.indexes == nil {+ t.indexes = map[string]*checkpointGitIndex{}+ }+ if idx, cached := t.indexes[repoRel]; cached {+ return idx+ }+ idx := &checkpointGitIndex{}+ t.indexes[repoRel] = idx+ if indexInfo, statErr := t.base.Lstat(filepath.FromSlash(pathpkg.Join(repoRel, ".git/index"))); statErr == nil {+ if !indexInfo.Mode().IsRegular() {+ return idx+ }+ } else if !os.IsNotExist(statErr) {+ return idx+ }+ repoAbs := t.root+ if repoRel != "." {+ repoAbs = filepath.Join(t.root, filepath.FromSlash(repoRel))+ }+ parentCtx := t.ctx+ if parentCtx == nil {+ parentCtx = context.Background()+ }+ cmdCtx, cancel := context.WithTimeout(parentCtx, checkpointGitIndexTimeout)+ defer cancel()+ // Pin git-dir/work-tree and disable executable repo config keys, matching+ // gitwork.checkoutGit so scanning a sandbox-controlled repo stays safe.+ cmd := exec.CommandContext(cmdCtx, "git",+ "--git-dir="+filepath.Join(repoAbs, ".git"),+ "--work-tree="+repoAbs,+ "-c", "safe.directory=*",+ "-c", "core.fsmonitor=",+ "-c", "core.hooksPath="+os.DevNull,+ "-c", "core.pager=cat",+ "-c", "core.editor=true",+ "-c", "core.askPass=",+ "-c", "credential.helper=",+ "ls-files", "-z", "--",+ )+ cmd.WaitDelay = time.Second+ cmd.Dir = repoAbs+ env := make([]string, 0, len(os.Environ())+7)+ for _, entry := range os.Environ() {+ name, _, _ := strings.Cut(entry, "=")+ switch name {+ case "GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES", "GIT_COMMON_DIR", "GIT_CONFIG_PARAMETERS", "GIT_CONFIG_COUNT":+ continue+ }+ env = append(env, entry)+ }+ cmd.Env = append(env,+ "GIT_CONFIG_NOSYSTEM=1",+ "GIT_CONFIG_GLOBAL="+os.DevNull,+ "GIT_TERMINAL_PROMPT=0",+ "GIT_OPTIONAL_LOCKS=0",+ "GIT_PAGER=cat",+ "GIT_ASKPASS=",+ "SSH_ASKPASS=",+ )+ out := &checkpointLimitedBuffer{limit: checkpointGitOutputMaxBytes}+ cmd.Stdout = out+ if err := cmd.Run(); err != nil || out.overflow || out.buf.Len() == 0 {+ return idx+ }+ idx.files = map[string]bool{}+ idx.dirs = map[string]bool{}+ for _, raw := range bytes.Split(out.buf.Bytes(), []byte{0}) {+ if len(raw) == 0 {+ continue+ }+ p := filepath.ToSlash(string(raw))+ if !checkpointExcluded(p) || checkpointRestoreExcluded(p) {+ continue+ }+ idx.files[p] = true+ for dir := pathpkg.Dir(p); dir != "." && dir != ""; dir = pathpkg.Dir(dir) {+ if idx.dirs[dir] {+ break+ }+ idx.dirs[dir] = true+ }+ }+ return idx+}++func ensureReplaceableWorkspaceTarget(root string) (bool, error) {+ info, err := os.Lstat(root)+ if os.IsNotExist(err) {+ return false, nil+ }+ if err != nil {+ return false, err+ }+ if !info.IsDir() {+ return false, fmt.Errorf("workspace already exists; refusing to overwrite")+ }+ hasContent, err := WorkspaceDirHasContent(root)+ if err != nil {+ return false, err+ }+ if hasContent {+ return false, fmt.Errorf("workspace already exists; refusing to overwrite")+ }+ return true, nil+}++func replaceRestoredWorkspace(stage, root string) error {+ return replaceRestoredWorkspaceWithRaceHook(stage, root, nil)+}++func replaceRestoredWorkspaceWithRaceHook(stage, root string, beforeRename func()) error {+ exists, err := ensureReplaceableWorkspaceTarget(root)+ if err != nil {+ return err+ }+ if !exists {+ return os.Rename(stage, root)+ }+ if beforeRename != nil {+ beforeRename()+ }+ backupParent, err := os.MkdirTemp(filepath.Dir(root), ".workspace-replace-")+ if err != nil {+ return err+ }+ defer os.RemoveAll(backupParent)+ backup := filepath.Join(backupParent, "prev")+ if err := os.Rename(root, backup); err != nil {+ return err+ }+ hasContent, err := WorkspaceDirHasContent(backup)+ if err != nil || hasContent {+ _ = os.Rename(backup, root)+ if err != nil {+ return err+ }+ return fmt.Errorf("workspace already exists; refusing to overwrite")+ }+ if err := os.Rename(stage, root); err != nil {+ _ = os.Rename(backup, root)+ return err+ }+ return nil+}+func RestoreWorkspaceCheckpoint(root string, content []byte) error {if len(content) == 0 || len(content) > WorkspaceCheckpointMaxBytes {return fmt.Errorf("invalid workspace checkpoint size")@@ -192,9 +468,8 @@ func RestoreWorkspaceCheckpoint(root string, content []byte) error {}func RestoreWorkspaceCheckpointFrom(root string, source io.Reader) error {- if _, err := os.Lstat(root); err == nil {- return fmt.Errorf("workspace already exists; refusing to overwrite")- } else if !os.IsNotExist(err) {+ root = filepath.Clean(root)+ if _, err := ensureReplaceableWorkspaceTarget(root); err != nil {return err}if err := os.MkdirAll(filepath.Dir(root), 0700); err != nil {@@ -254,7 +529,7 @@ func RestoreWorkspaceCheckpointFrom(root string, source io.Reader) error {if limited.N == 0 || compressed.N == 0 {return fmt.Errorf("checkpoint expanded size exceeds limit")}- return os.Rename(stage, root)+ return replaceRestoredWorkspace(stage, root)}// restoreCheckpointEntry materializes one validated tar entry at path insidediff --git a/internal/runtime/workspace_checkpoint_excluded_test.go b/internal/runtime/workspace_checkpoint_excluded_test.goindex ab1c9b96..55f496bc 100644--- a/internal/runtime/workspace_checkpoint_excluded_test.go+++ b/internal/runtime/workspace_checkpoint_excluded_test.go@@ -9,9 +9,10 @@ func TestCheckpointExclusionNames(t *testing.T) {}{{"src/main.go", false, false},{".agentflow", true, true},- {"a/node_modules/x.js", true, true},- {"pkg/.cache/blob", true, true},- {"py/__pycache__/m.pyc", true, true},+ {"repo/.agentflow/token", true, true},+ {"a/node_modules/x.js", true, false},+ {"pkg/.cache/blob", true, false},+ {"py/__pycache__/m.pyc", true, false},{".zvec-grep/index", true, false},{"deep/.zvec-grep", true, false},{".cache2/file", false, false},@@ -29,7 +30,7 @@ func TestCheckpointExclusionNames(t *testing.T) {}func TestCheckpointExcludedNamesDoNotAliasRestoreNames(t *testing.T) {- if len(checkpointRestoreExcludedNames) != 4 || len(checkpointExcludedNames) != 5 {+ if len(checkpointRestoreExcludedNames) != 1 || len(checkpointExcludedNames) != 5 {t.Fatalf("unexpected exclusion lists: restore=%v capture=%v", checkpointRestoreExcludedNames, checkpointExcludedNames)}}diff --git a/internal/runtime/workspace_checkpoint_test.go b/internal/runtime/workspace_checkpoint_test.goindex dbc73460..4977faa0 100644--- a/internal/runtime/workspace_checkpoint_test.go+++ b/internal/runtime/workspace_checkpoint_test.go@@ -4,9 +4,14 @@ import ("archive/tar""bytes""compress/gzip"+ "context"+ "errors""os"+ "os/exec""path/filepath"+ "strings""testing"+ "time")func TestWorkspaceCheckpointRoundTrip(t *testing.T) {@@ -164,3 +169,290 @@ func TestWorkspaceCheckpointRestoreNeverWritesThroughExternalSymlinks(t *testing})}}++func TestWorkspaceCheckpointPreservesTrackedFilesUnderExcludedDirsWhileSkippingUntracked(t *testing.T) {+ root := t.TempDir()+ repoDir := filepath.Join(root, "repo")+ if err := os.MkdirAll(repoDir, 0o700); err != nil {+ t.Fatal(err)+ }+ git := func(dir string, args ...string) string {+ t.Helper()+ cmd := exec.Command("git", append([]string{"-c", "core.hooksPath=/dev/null", "-C", dir}, args...)...)+ cmd.Env = append(os.Environ(),+ "GIT_CONFIG_GLOBAL=/dev/null",+ "GIT_CONFIG_NOSYSTEM=1",+ "GIT_AUTHOR_NAME=Checkpoint Test",+ "[email protected]",+ "GIT_COMMITTER_NAME=Checkpoint Test",+ "[email protected]",+ )+ out, err := cmd.CombinedOutput()+ if err != nil {+ t.Fatalf("git %v: %s %v", args, out, err)+ }+ return string(out)+ }+ write := func(rel, body string) {+ t.Helper()+ full := filepath.Join(root, filepath.FromSlash(rel))+ if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(full, []byte(body), 0o644); err != nil {+ t.Fatal(err)+ }+ }++ git(repoDir, "init", "-q", "-b", "main")+ write("repo/web/vscode-web/node_modules/@microsoft/1ds/dist/ms.core.min.js", "v1\n")+ write("repo/web/vscode-web/node_modules/pkg/target.txt", "target\n")+ write("repo/assets/.cache/manifest.json", "{\"ok\":true}\n")+ write("repo/py/__pycache__/keep.pyc", "pyc-tracked")+ write("repo/.agentflow/committed-secret", "must-never-capture")+ if err := os.Symlink("../pkg/target.txt", filepath.Join(repoDir, "web/vscode-web/node_modules/@microsoft/link")); err != nil {+ t.Fatal(err)+ }+ git(repoDir, "add", "-f",+ "web/vscode-web/node_modules/@microsoft/1ds/dist/ms.core.min.js",+ "web/vscode-web/node_modules/pkg/target.txt",+ "web/vscode-web/node_modules/@microsoft/link",+ "assets/.cache/manifest.json",+ "py/__pycache__/keep.pyc",+ ".agentflow/committed-secret",+ )+ git(repoDir, "commit", "-qm", "track vendored assets")++ // Unstaged edit and staged new file inside node_modules must keep their live contents.+ write("repo/web/vscode-web/node_modules/@microsoft/1ds/dist/ms.core.min.js", "v2-modified\n")+ write("repo/web/vscode-web/node_modules/staged.js", "staged\n")+ git(repoDir, "add", "-f", "web/vscode-web/node_modules/staged.js")++ // Untracked dependencies/caches inside the same repo and workspace must stay excluded.+ write("repo/chatbot/node_modules/huge/index.js", "npm-dep\n")+ write("repo/web/vscode-web/node_modules/untracked/dep.js", "untracked-dep\n")+ write("repo/assets/.cache/ephemeral.bin", "tmp")+ write("repo/py/__pycache__/ephemeral.pyc", "tmp")+ write("repo/.zvec-grep/index", "idx")+ write(".agentflow/auth/token", "host-secret")++ archive, err := CreateWorkspaceCheckpoint(root)+ if err != nil {+ t.Fatal(err)+ }+ dest := filepath.Join(t.TempDir(), "restored")+ if err := RestoreWorkspaceCheckpoint(dest, archive); err != nil {+ t.Fatal(err)+ }++ wantPreserved := map[string]string{+ "repo/web/vscode-web/node_modules/@microsoft/1ds/dist/ms.core.min.js": "v2-modified\n",+ "repo/web/vscode-web/node_modules/pkg/target.txt": "target\n",+ "repo/web/vscode-web/node_modules/staged.js": "staged\n",+ "repo/assets/.cache/manifest.json": "{\"ok\":true}\n",+ "repo/py/__pycache__/keep.pyc": "pyc-tracked",+ }+ for rel, want := range wantPreserved {+ got, err := os.ReadFile(filepath.Join(dest, filepath.FromSlash(rel)))+ if err != nil || string(got) != want {+ t.Fatalf("restored %s = %q (%v), want %q", rel, got, err, want)+ }+ }+ if link, err := os.Readlink(filepath.Join(dest, "repo/web/vscode-web/node_modules/@microsoft/link")); err != nil || link != "../pkg/target.txt" {+ t.Fatalf("restored symlink = %q (%v)", link, err)+ }+ for _, excluded := range []string{+ "repo/chatbot/node_modules",+ "repo/web/vscode-web/node_modules/untracked",+ "repo/assets/.cache/ephemeral.bin",+ "repo/py/__pycache__/ephemeral.pyc",+ "repo/.zvec-grep",+ "repo/.agentflow",+ ".agentflow",+ } {+ if _, err := os.Lstat(filepath.Join(dest, filepath.FromSlash(excluded))); !os.IsNotExist(err) {+ t.Fatalf("untracked or secret path %s should not be restored", excluded)+ }+ }+ status := git(filepath.Join(dest, "repo"), "status", "--short")+ for _, line := range strings.Split(strings.TrimSpace(status), "\n") {+ if strings.HasPrefix(strings.TrimSpace(line), "D ") && !strings.Contains(line, ".agentflow/") {+ t.Fatalf("restored repo has missing tracked file %q\nfull status:\n%s", line, status)+ }+ }+}++func TestRestoreWorkspaceCheckpointReplacesEmptyAndRuntimeOnlyDirectoryAtomically(t *testing.T) {+ src := t.TempDir()+ if err := os.WriteFile(filepath.Join(src, "app.txt"), []byte("restored"), 0o600); err != nil {+ t.Fatal(err)+ }+ archive, err := CreateWorkspaceCheckpoint(src)+ if err != nil {+ t.Fatal(err)+ }++ t.Run("empty-dir", func(t *testing.T) {+ dest := filepath.Join(t.TempDir(), "ws")+ if err := os.MkdirAll(dest, 0o700); err != nil {+ t.Fatal(err)+ }+ if err := RestoreWorkspaceCheckpoint(dest, archive); err != nil {+ t.Fatal(err)+ }+ got, err := os.ReadFile(filepath.Join(dest, "app.txt"))+ if err != nil || string(got) != "restored" {+ t.Fatalf("restored app.txt = %q (%v)", got, err)+ }+ })++ t.Run("agentflow-only-dir", func(t *testing.T) {+ dest := filepath.Join(t.TempDir(), "ws")+ if err := os.MkdirAll(filepath.Join(dest, ".agentflow", "hooks"), 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(dest, ".agentflow", "hooks", "pre.json"), []byte("{}"), 0o600); err != nil {+ t.Fatal(err)+ }+ if err := RestoreWorkspaceCheckpoint(dest, archive); err != nil {+ t.Fatal(err)+ }+ got, err := os.ReadFile(filepath.Join(dest, "app.txt"))+ if err != nil || string(got) != "restored" {+ t.Fatalf("restored app.txt = %q (%v)", got, err)+ }+ if _, err := os.Lstat(filepath.Join(dest, ".agentflow")); !os.IsNotExist(err) {+ t.Fatalf("stale .agentflow should have been replaced, stat err=%v", err)+ }+ })++ t.Run("corrupt-archive-preserves-target", func(t *testing.T) {+ dest := filepath.Join(t.TempDir(), "ws")+ marker := filepath.Join(dest, ".agentflow", "hooks", "pre.json")+ if err := os.MkdirAll(filepath.Dir(marker), 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(marker, []byte("keep"), 0o600); err != nil {+ t.Fatal(err)+ }+ if err := RestoreWorkspaceCheckpoint(dest, []byte("not-gzip")); err == nil {+ t.Fatal("corrupt archive accepted")+ }+ got, err := os.ReadFile(marker)+ if err != nil || string(got) != "keep" {+ t.Fatalf("corrupt archive altered target: %q (%v)", got, err)+ }+ })++ t.Run("real-file-refuses-overwrite", func(t *testing.T) {+ dest := filepath.Join(t.TempDir(), "ws")+ if err := os.MkdirAll(dest, 0o700); err != nil {+ t.Fatal(err)+ }+ existing := filepath.Join(dest, "surviving.txt")+ if err := os.WriteFile(existing, []byte("survive"), 0o600); err != nil {+ t.Fatal(err)+ }+ if err := RestoreWorkspaceCheckpoint(dest, archive); err == nil {+ t.Fatal("existing workspace overwritten")+ }+ got, err := os.ReadFile(existing)+ if err != nil || string(got) != "survive" {+ t.Fatalf("surviving file altered: %q (%v)", got, err)+ }+ })+}++func TestCheckpointGitTrackerTimeoutsDegradeToUntracked(t *testing.T) {+ root := t.TempDir()+ repo := filepath.Join(root, "repo")+ if err := os.MkdirAll(filepath.Join(repo, ".git"), 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(repo, ".git", "HEAD"), []byte("ref: refs/heads/main\n"), 0o600); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(repo, ".git", "index"), []byte{}, 0o600); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Join(repo, "node_modules", "pkg"), 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(repo, "node_modules", "pkg", "index.js"), []byte("tracked"), 0o600); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(repo, "app.txt"), []byte("app"), 0o600); err != nil {+ t.Fatal(err)+ }++ bin := t.TempDir()+ fakeGit := filepath.Join(bin, "git")+ if err := os.WriteFile(fakeGit, []byte("#!/bin/sh\nsleep 10\n"), 0o755); err != nil {+ t.Fatal(err)+ }+ t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))+ prevTimeout := checkpointGitIndexTimeout+ checkpointGitIndexTimeout = 100 * time.Millisecond+ t.Cleanup(func() { checkpointGitIndexTimeout = prevTimeout })++ archive, err := CreateWorkspaceCheckpointContext(context.Background(), root)+ if err != nil {+ t.Fatalf("CreateWorkspaceCheckpointContext failed: %v", err)+ }+ dest := filepath.Join(t.TempDir(), "restored")+ if err := RestoreWorkspaceCheckpoint(dest, archive); err != nil {+ t.Fatalf("RestoreWorkspaceCheckpoint failed: %v", err)+ }+ if got, err := os.ReadFile(filepath.Join(dest, "repo", "app.txt")); err != nil || string(got) != "app" {+ t.Fatalf("expected repo/app.txt restored, got %q (%v)", got, err)+ }+ if _, err := os.Lstat(filepath.Join(dest, "repo", "node_modules", "pkg", "index.js")); !os.IsNotExist(err) {+ t.Fatalf("expected timed-out git index lookup to degrade and skip node_modules, err=%v", err)+ }+}++func TestCheckpointGitTrackerOverflowAndContextCancel(t *testing.T) {+ buf := &checkpointLimitedBuffer{limit: 4}+ if _, err := buf.Write([]byte("hello")); err == nil || !buf.overflow {+ t.Fatalf("expected overflow error, overflow=%v err=%v", buf.overflow, err)+ }++ root := t.TempDir()+ if err := os.WriteFile(filepath.Join(root, "a.txt"), []byte("data"), 0o600); err != nil {+ t.Fatal(err)+ }+ ctx, cancel := context.WithCancel(context.Background())+ cancel()+ if _, err := CreateWorkspaceCheckpointContext(ctx, root); !errors.Is(err, context.Canceled) {+ t.Fatalf("expected context.Canceled, got %v", err)+ }+}++func TestReplaceRestoredWorkspaceRollsBackOnConcurrentWrite(t *testing.T) {+ parent := t.TempDir()+ root := filepath.Join(parent, "ws")+ stage := filepath.Join(parent, "stage")+ if err := os.MkdirAll(filepath.Join(root, ".agentflow"), 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(stage, 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(stage, "from-snapshot.txt"), []byte("snap"), 0o600); err != nil {+ t.Fatal(err)+ }++ err := replaceRestoredWorkspaceWithRaceHook(stage, root, func() {+ _ = os.WriteFile(filepath.Join(root, "raced.txt"), []byte("concurrent"), 0o600)+ })+ if err == nil || !strings.Contains(err.Error(), "refusing to overwrite") {+ t.Fatalf("expected refusing to overwrite error, got %v", err)+ }+ got, readErr := os.ReadFile(filepath.Join(root, "raced.txt"))+ if readErr != nil || string(got) != "concurrent" {+ t.Fatalf("concurrent file was not preserved after rollback: %q (%v)", got, readErr)+ }+ if _, snapErr := os.Lstat(filepath.Join(root, "from-snapshot.txt")); !os.IsNotExist(snapErr) {+ t.Fatalf("stage snapshot leaked into target after rollback: %v", snapErr)+ }+}diff --git a/internal/runtime/workspace_checkpoint_transfer.go b/internal/runtime/workspace_checkpoint_transfer.goindex 4a7c6860..dad472b7 100644--- a/internal/runtime/workspace_checkpoint_transfer.go+++ b/internal/runtime/workspace_checkpoint_transfer.go@@ -46,7 +46,12 @@ func WorkspaceCheckpointStatus(root string) domain.RunnerWorkspaceResponse {if !info.IsDir() {return domain.RunnerWorkspaceResponse{Status: 409, Error: "workspace is not a directory"}}- return domain.RunnerWorkspaceResponse{Status: 200, Payload: json.RawMessage(`{"exists":true}`)}+ hasContent, err := WorkspaceDirHasContent(root)+ if err != nil {+ return domain.RunnerWorkspaceResponse{Status: 409, Error: err.Error()}+ }+ payload, _ := json.Marshal(map[string]bool{"exists": true, "empty": !hasContent})+ return domain.RunnerWorkspaceResponse{Status: 200, Payload: payload}}func (p *CheckpointTransfers) Sweep(now time.Time) {@@ -134,7 +139,7 @@ func (p *CheckpointTransfers) handle(ctx context.Context, root string, req domaiitem.info.ID = hex.EncodeToString(raw)if op == domain.RunnerWorkspaceOperationCheckpointExport {hash := sha256.New()- if err = CreateWorkspaceCheckpointTo(root, checkpointContextWriter{ctx, io.MultiWriter(f, hash)}); err != nil {+ if err = CreateWorkspaceCheckpointToContext(ctx, root, checkpointContextWriter{ctx, io.MultiWriter(f, hash)}); err != nil {return nil, err}stat, err := f.Stat()diff --git a/internal/runtime/workspace_checkpoint_unix_test.go b/internal/runtime/workspace_checkpoint_unix_test.gonew file mode 100644index 00000000..c3596cc7--- /dev/null+++ b/internal/runtime/workspace_checkpoint_unix_test.go@@ -0,0 +1,51 @@+//go:build unix++package runtime++import (+ "context"+ "os"+ "path/filepath"+ "strings"+ "syscall"+ "testing"+ "time"+)++func TestCreateWorkspaceCheckpointRejectsGitIndexFIFOImmediately(t *testing.T) {+ root := t.TempDir()+ repo := filepath.Join(root, "repo")+ if err := os.MkdirAll(filepath.Join(repo, ".cache"), 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(repo, ".cache", "x"), []byte("cache"), 0o600); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Join(repo, ".git"), 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(repo, ".git", "HEAD"), []byte("ref: refs/heads/main\n"), 0o600); err != nil {+ t.Fatal(err)+ }+ indexPath := filepath.Join(repo, ".git", "index")+ if err := syscall.Mkfifo(indexPath, 0o600); err != nil {+ t.Fatalf("mkfifo: %v", err)+ }++ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)+ defer cancel()+ done := make(chan error, 1)+ go func() {+ _, err := CreateWorkspaceCheckpointContext(ctx, root)+ done <- err+ }()++ select {+ case err := <-done:+ if err == nil || !strings.Contains(err.Error(), "unsupported checkpoint file") {+ t.Fatalf("expected unsupported checkpoint file error, got %v", err)+ }+ case <-time.After(2 * time.Second):+ t.Fatal("CreateWorkspaceCheckpointContext hung on FIFO .git/index")+ }+}