hammerkit 1.6.0 → 1.8.0

package/dist/planner/work-graph-serializer.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeWorkGraph = void 0;
+const plan_work_tasks_1 = require("./utils/plan-work-tasks");
+const validate_1 = require("./validate");
+function buildGraph(workTree) {
+    const taskItems = Array.from((0, plan_work_tasks_1.iterateWorkTasks)(workTree)).sort((a, b) => a.name.localeCompare(b.name));
+    const serviceItems = Array.from((0, plan_work_tasks_1.iterateWorkServices)(workTree)).sort((a, b) => a.name.localeCompare(b.name));
+    const nodes = [];
+    const taskNodeId = new Map();
+    const serviceNodeId = new Map();
+    taskItems.forEach((task, index) => {
+        const id = `t${index}`;
+        taskNodeId.set(task.name, id);
+        nodes.push({ id, name: task.name, kind: 'task' });
+    });
+    serviceItems.forEach((service, index) => {
+        const id = `s${index}`;
+        serviceNodeId.set(service.name, id);
+        nodes.push({ id, name: service.name, kind: 'service' });
+    });
+    const edges = [];
+    for (const task of taskItems) {
+        const from = taskNodeId.get(task.name);
+        if (!from) {
+            continue;
+        }
+        for (const dep of task.deps) {
+            const to = taskNodeId.get(dep.name);
+            if (to) {
+                edges.push({ from, to, kind: 'deps' });
+            }
+        }
+        for (const need of task.needs) {
+            const to = serviceNodeId.get(need.service.name);
+            if (to) {
+                edges.push({ from, to, kind: 'needs' });
+            }
+        }
+    }
+    edges.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.kind.localeCompare(b.kind));
+    let cycle = null;
+    for (const task of taskItems) {
+        const path = (0, validate_1.hasDependencyCycle)(task, []);
+        if (path && path.length > 0) {
+            cycle = path.map((n) => n.name);
+            break;
+        }
+    }
+    return { nodes, edges, cycle };
+}
+function mermaidLabel(name) {
+    return name.replace(/"/g, "'");
+}
+function renderMermaid(nodes, edges, cycle) {
+    const lines = ['graph TD'];
+    for (const node of nodes) {
+        // tasks are rectangles, services are stadium-shaped, so the two are visually distinct
+        lines.push(node.kind === 'task'
+            ? `  ${node.id}["${mermaidLabel(node.name)}"]`
+            : `  ${node.id}(["${mermaidLabel(node.name)}"])`);
+    }
+    for (const edge of edges) {
+        // deps are solid arrows, needs are dotted — distinct edge types
+        lines.push(edge.kind === 'deps' ? `  ${edge.from} --> ${edge.to}` : `  ${edge.from} -.-> ${edge.to}`);
+    }
+    if (cycle) {
+        lines.push(`  %% cycle detected: ${cycle.join(' -> ')}`);
+    }
+    return lines.join('\n');
+}
+function dotId(id) {
+    return `"${id}"`;
+}
+function dotLabel(name) {
+    return name.replace(/"/g, '\\"');
+}
+function renderDot(nodes, edges, cycle) {
+    const lines = ['digraph hammerkit {'];
+    if (cycle) {
+        lines.push(`  // cycle detected: ${cycle.join(' -> ')}`);
+    }
+    for (const node of nodes) {
+        const shape = node.kind === 'task' ? 'box' : 'ellipse';
+        lines.push(`  ${dotId(node.id)} [label="${dotLabel(node.name)}" shape=${shape}];`);
+    }
+    for (const edge of edges) {
+        const style = edge.kind === 'needs' ? ' [style=dotted]' : '';
+        lines.push(`  ${dotId(edge.from)} -> ${dotId(edge.to)}${style};`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+// Serialize the planner's already-built work graph (tasks, services, deps and
+// needs edges) into a renderable format. A cyclic graph still renders and marks
+// the cycle rather than crashing.
+function serializeWorkGraph(workTree, format) {
+    const { nodes, edges, cycle } = buildGraph(workTree);
+    const output = format === 'dot' ? renderDot(nodes, edges, cycle) : renderMermaid(nodes, edges, cycle);
+    return { output, cycle };
+}
+exports.serializeWorkGraph = serializeWorkGraph;
+//# sourceMappingURL=work-graph-serializer.js.map

package/dist/planner/work-instance-id.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkInstanceId = void 0;
+const crypto_1 = require("crypto");
+// `id()` is the portable cache identity: identical for the same task in every
+// checkout, so a shared cache hits across machines. Machine-local runtime state
+// (docker container labels, the cache staging directory) must instead stay
+// scoped to one checkout — two worktrees of the same repo on one host would
+// otherwise see each other's paused containers and staging files. The instance
+// id folds the absolute project root into the portable id for that purpose.
+function getWorkInstanceId(item) {
+    return (0, crypto_1.createHash)('sha1').update(`${item.id()}\0${item.data.projectRoot}`).digest('hex');
+}
+exports.getWorkInstanceId = getWorkInstanceId;
+//# sourceMappingURL=work-instance-id.js.map

package/dist/planner/work-runtime-docker.js

@@ -9,14 +9,17 @@ const using_container_1 = require("../docker/using-container");
 const event_cache_1 = require("../executer/event-cache");
 const get_docker_executor_1 = require("../executer/get-docker-executor");
 const path_1 = require("path");
+const tar_1 = require("tar");
 const plan_work_volume_1 = require("./utils/plan-work-volume");
+const work_instance_id_1 = require("./work-instance-id");
+const stream_1 = require("stream");
 function dockerTaskRuntime(task, workEnvironment) {
     const docker = (0, execute_docker_1.getContainerCli)(workEnvironment);
     return {
         async initialize(state) {
             const currentTasks = await docker.listContainers({
                 filters: {
-                    label: [`hammerkit-id=${task.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(task)}`],
                 },
             });
             const currentTask = currentTasks[0];
@@ -40,7 +43,7 @@ function dockerTaskRuntime(task, workEnvironment) {
             const containers = await docker.listContainers({
                 all: true,
                 filters: {
-                    label: [`hammerkit-id=${task.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(task)}`],
                 },
             });
             for (const container of containers) {
@@ -66,11 +69,11 @@ function dockerTaskRuntime(task, workEnvironment) {
                 }
             }
         },
-        async currentStateKey() {
+        async currentStateKey(environment) {
             const containers = await docker.listContainers({
                 all: true,
                 filters: {
-                    label: [`hammerkit-id=${task.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(task)}`],
                 },
             });
             const container = containers[0];
@@ -80,11 +83,26 @@ function dockerTaskRuntime(task, workEnvironment) {
             if (!container.Labels['hammerkit-state']) {
                 return null;
             }
+            // outputs removed since the run (a deleted export, a pruned volume)
+            // leave nothing to reuse
+            for (const generate of task.data.generates.filter((g) => !g.inherited)) {
+                const present = isOnHost(generate)
+                    ? await environment.file.exists(generate.path)
+                    : !!(await (0, get_docker_executor_1.existsVolume)(docker, generate.volumeName));
+                if (!present) {
+                    return null;
+                }
+            }
             return container.Labels['hammerkit-state'];
         },
     };
 }
 exports.dockerTaskRuntime = dockerTaskRuntime;
+// File outputs are bind mounts of host files and exported directories are
+// copied to the host, so both must be present on the host, not only in a volume.
+function isOnHost(generate) {
+    return generate.isFile || generate.export;
+}
 async function restoreContainer(docker, environment, item, path) {
     await (0, using_container_1.usingContainer)(docker, item, {
         abortSignal: environment.abortCtrl.signal,
@@ -95,25 +113,44 @@ async function restoreContainer(docker, environment, item, path) {
         WorkingDir: (0, execute_docker_1.convertToPosixPath)(item.data.cwd),
         Labels: {
             app: 'hammerkit',
-            'hammerkit-id': item.id(),
+            'hammerkit-id': (0, work_instance_id_1.getWorkInstanceId)(item),
             'hammerkit-pid': process.pid.toString(),
             'hammerkit-type': 'task',
         },
         HostConfig: {
             AutoRemove: true,
-            Binds: item.data.type === 'container-task'
-                ? []
-                : [...item.data.volumes.map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`)],
+            // mount the same volumes archiveContainer reads from, so the restored
+            // archives land in the task's output volumes rather than in this
+            // throwaway container's filesystem
+            Binds: item.data.type === 'container-service'
+                ? item.data.volumes
+                    .filter((v) => !v.inherited)
+                    .map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`)
+                : item.data.generates
+                    .filter((v) => !v.inherited && !v.isFile)
+                    .map((v) => `${v.volumeName}:${(0, execute_docker_1.convertToPosixPath)(v.path)}`),
         },
     }, null, async (container) => {
         for (const generate of (0, event_cache_1.getArchivePaths)(item.data, path)) {
             if (await environment.file.exists(generate.filename)) {
+                // a cache hit means exactly the stored outputs: whatever a failed or
+                // older run left in the volume goes first
+                await (0, execute_docker_1.clearContainerDirectory)(item.status, environment, container, generate.path);
                 await container.putArchive(environment.file.readStream(generate.filename), {
                     path: (0, path_1.dirname)(generate.path),
                 });
             }
         }
     });
+    if (item.data.type === 'container-task') {
+        const onHost = new Set(item.data.generates.filter((g) => !g.inherited && isOnHost(g)).map((g) => g.path));
+        for (const generate of (0, event_cache_1.getArchivePaths)(item.data, path)) {
+            if (onHost.has(generate.path) && (await environment.file.exists(generate.filename))) {
+                await environment.file.remove(generate.path);
+                await (0, tar_1.extract)({ file: generate.filename, cwd: (0, path_1.dirname)(generate.path) });
+            }
+        }
+    }
 }
 function dockerServiceRuntime(service, workEnvironment) {
     const docker = (0, execute_docker_1.getContainerCli)(workEnvironment);
@@ -121,7 +158,7 @@ function dockerServiceRuntime(service, workEnvironment) {
         async initialize(state) {
             const currentServices = await docker.listContainers({
                 filters: {
-                    label: [`hammerkit-id=${service.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(service)}`],
                 },
             });
             const currentService = currentServices[0];
@@ -143,7 +180,7 @@ function dockerServiceRuntime(service, workEnvironment) {
             const containers = await docker.listContainers({
                 all: true,
                 filters: {
-                    label: [`hammerkit-id=${service.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(service)}`],
                 },
             });
             for (const container of containers) {
@@ -173,7 +210,7 @@ function dockerServiceRuntime(service, workEnvironment) {
             const containers = await docker.listContainers({
                 all: true,
                 filters: {
-                    label: [`hammerkit-id=${service.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(service)}`],
                 },
             });
             const container = containers[0];
@@ -198,7 +235,7 @@ async function archiveContainer(docker, environment, item, path) {
         WorkingDir: (0, execute_docker_1.convertToPosixPath)(item.data.cwd),
         Labels: {
             app: 'hammerkit',
-            'hammerkit-id': item.id(),
+            'hammerkit-id': (0, work_instance_id_1.getWorkInstanceId)(item),
             'hammerkit-pid': process.pid.toString(),
             'hammerkit-type': 'task',
         },
@@ -213,10 +250,16 @@ async function archiveContainer(docker, environment, item, path) {
                     .map((v) => `${v.volumeName}:${(0, execute_docker_1.convertToPosixPath)(v.path)}`),
         },
     }, null, async (container) => {
+        const hostFiles = new Set(item.data.type === 'container-task'
+            ? item.data.generates.filter((g) => !g.inherited && g.isFile).map((g) => g.path)
+            : []);
         for (const generatedArchive of (0, event_cache_1.getArchivePaths)(item.data, path)) {
-            const readable = await container.getArchive({
-                path: generatedArchive.path,
-            });
+            // a file output is a bind mount of a host file, so archive it from the host
+            const readable = hostFiles.has(generatedArchive.path)
+                ? stream_1.Readable.from((0, tar_1.create)({ cwd: (0, path_1.dirname)(generatedArchive.path) }, [(0, path_1.basename)(generatedArchive.path)]))
+                : await container.getArchive({
+                    path: generatedArchive.path,
+                });
             await environment.file.writeStream(generatedArchive.filename, readable);
         }
     });

package/dist/planner/work-runtime-kubernetes.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.kubernetesForwardRuntime = exports.kubernetesServiceRuntime = exports.kubernetesTaskRuntime = void 0;
+const abort_1 = require("../executer/abort");
 const kubernetes_service_1 = require("../executer/kubernetes-service");
 const kubernetes_instance_1 = require("../kubernetes/kubernetes-instance");
 const replace_env_variables_1 = require("../environment/replace-env-variables");
@@ -15,7 +16,6 @@ const ensure_persistent_data_1 = require("../kubernetes/ensure-persistent-data")
 const await_running_state_1 = require("../kubernetes/await-running-state");
 const volumes_1 = require("../kubernetes/volumes");
 const resources_1 = require("../kubernetes/resources");
-const ensure_ingress_1 = require("../kubernetes/ensure-ingress");
 const ensure_http_route_1 = require("../kubernetes/ensure-http-route");
 const find_process_1 = __importDefault(require("find-process"));
 const log_1 = require("../log");
@@ -23,9 +23,12 @@ const version_1 = require("../version");
 const restore_kubernetes_data_1 = require("../kubernetes/restore-kubernetes-data");
 const store_kubernetes_data_1 = require("../kubernetes/store-kubernetes-data");
 const remove_persistent_data_1 = require("../kubernetes/remove-persistent-data");
-function statusCodeOf(e) {
-    const err = e;
-    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
+async function listJobNames(instance, kubernetes, task) {
+    const jobs = await instance.batchApi.listNamespacedJob({
+        namespace: kubernetes.namespace,
+        labelSelector: `hammerkit.dev/id=${task.id()}`,
+    });
+    return jobs.items.flatMap((job) => (job.metadata?.name ? [job.metadata.name] : []));
 }
 function kubernetesTaskRuntime(task, kubernetes) {
     const instance = (0, kubernetes_instance_1.createKubernetesInstances)(kubernetes);
@@ -44,6 +47,11 @@ function kubernetesTaskRuntime(task, kubernetes) {
             const persistence = await (0, volumes_1.getKubernetesPersistence)(task);
             await (0, ensure_namespace_1.ensureNamespace)(instance, kubernetes.namespace);
             await (0, ensure_persistent_data_1.ensurePersistentData)(instance, kubernetes, environment, task, persistence);
+            // The last job of a run stays: its state label is what currentStateKey
+            // reads. Jobs from an earlier run of this task go before this one starts.
+            for (const name of await listJobNames(instance, kubernetes, task)) {
+                await (0, await_running_state_1.deleteJobAndWait)(instance, kubernetes, name, options.abort);
+            }
             const podName = `${task.name}-${options.stateKey}`;
             let i = 0;
             for (const cmd of task.data.cmds) {
@@ -95,12 +103,19 @@ function kubernetesTaskRuntime(task, kubernetes) {
                 try {
                     const pod = await (0, apply_1.apply)(instance, spec);
                     if (!pod.status?.succeeded) {
-                        await (0, await_running_state_1.awaitJobState)(instance, kubernetes, spec.metadata.name);
+                        await (0, await_running_state_1.awaitJobCompletion)(instance, kubernetes, spec.metadata.name, options.abort);
                     }
                     task.status.write('debug', 'pod completed');
-                    await instance.batchApi.deleteNamespacedJob(podName, kubernetes.namespace);
+                    if (i < task.data.cmds.length) {
+                        await (0, await_running_state_1.deleteJobAndWait)(instance, kubernetes, podName, options.abort);
+                    }
                 }
                 catch (e) {
+                    if (e instanceof abort_1.AbortError) {
+                        options.state.set({ stateKey: options.stateKey, type: 'canceled' });
+                        return;
+                    }
+                    await (0, await_running_state_1.deleteJob)(instance, kubernetes, podName).catch(() => undefined);
                     options.state.set({
                         stateKey: options.stateKey,
                         type: 'error',
@@ -111,22 +126,34 @@ function kubernetesTaskRuntime(task, kubernetes) {
             }
         },
         async stop() {
-            const jobs = await instance.batchApi.listNamespacedJob(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-            for (const pod of jobs.body.items) {
+            const jobs = await instance.batchApi.listNamespacedJob({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const pod of jobs.items) {
                 if (pod.metadata?.name) {
-                    await instance.batchApi.deleteNamespacedJob(pod.metadata.name, kubernetes.namespace);
+                    await instance.batchApi.deleteNamespacedJob({ name: pod.metadata.name, namespace: kubernetes.namespace });
                 }
             }
-            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-            for (const deploy of deployments.body.items) {
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const deploy of deployments.items) {
                 if (deploy.metadata?.name) {
-                    await instance.appsApi.deleteNamespacedDeployment(deploy.metadata.name, kubernetes.namespace);
+                    await instance.appsApi.deleteNamespacedDeployment({
+                        name: deploy.metadata.name,
+                        namespace: kubernetes.namespace,
+                    });
                 }
             }
-            const pods = await instance.coreApi.listNamespacedPod(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-            for (const pod of pods.body.items) {
+            const pods = await instance.coreApi.listNamespacedPod({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const pod of pods.items) {
                 if (pod.metadata?.name) {
-                    await instance.coreApi.deleteNamespacedPod(pod.metadata.name, kubernetes.namespace);
+                    await instance.coreApi.deleteNamespacedPod({ name: pod.metadata.name, namespace: kubernetes.namespace });
                 }
             }
         },
@@ -135,11 +162,32 @@ function kubernetesTaskRuntime(task, kubernetes) {
             await (0, remove_persistent_data_1.removePersistentData)(instance, kubernetes, task);
         },
         async currentStateKey() {
-            const jobs = await instance.batchApi.listNamespacedJob(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-            const completedStates = jobs.body.items
+            const jobs = await instance.batchApi.listNamespacedJob({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            const completedStates = jobs.items
                 .filter((j) => j.status?.succeeded && j.metadata?.labels?.['hammerkit.dev/state'])
                 .map((j) => j.metadata.labels['hammerkit.dev/state']);
-            return completedStates[completedStates.length - 1] ?? null;
+            const stateKey = completedStates[completedStates.length - 1] ?? null;
+            if (stateKey === null || !task.data.generates.some((g) => !g.inherited)) {
+                return stateKey;
+            }
+            // outputs live in the task's claim; without it the finished job left
+            // nothing to reuse
+            try {
+                const claim = await instance.coreApi.readNamespacedPersistentVolumeClaim({
+                    name: (0, volumes_1.getVolumeName)(task),
+                    namespace: kubernetes.namespace,
+                });
+                return claim.metadata?.deletionTimestamp ? null : stateKey;
+            }
+            catch (e) {
+                if ((0, apply_1.statusCodeOf)(e) === 404) {
+                    return null;
+                }
+                throw e;
+            }
         },
     };
 }
@@ -157,10 +205,16 @@ function kubernetesServiceRuntime(service, kubernetes) {
             await (0, store_kubernetes_data_1.storeKubernetesData)(service, kubernetes, instance, environment, path);
         },
         async stop() {
-            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
-            for (const deployment of deployments.body.items) {
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            for (const deployment of deployments.items) {
                 if (deployment.metadata?.name) {
-                    await instance.appsApi.deleteNamespacedDeployment(deployment.metadata.name, kubernetes.namespace);
+                    await instance.appsApi.deleteNamespacedDeployment({
+                        name: deployment.metadata.name,
+                        namespace: kubernetes.namespace,
+                    });
                 }
             }
         },
@@ -177,29 +231,16 @@ function kubernetesServiceRuntime(service, kubernetes) {
                 stateKey: options.stateKey,
                 remote: null,
             });
-            const ingresses = kubernetes.ingresses.filter((i) => i.service === service.name);
-            for (const ingress of ingresses) {
-                if (ingress.kind === 'httproute') {
-                    await (0, ensure_http_route_1.ensureHttpRoute)(instance, kubernetes, ingress, service);
-                }
-                else {
-                    await (0, ensure_ingress_1.ensureIngress)(instance, kubernetes, ingress, service);
-                }
+            for (const route of kubernetes.httpRoutes.filter((r) => r.service === service.name)) {
+                await (0, ensure_http_route_1.ensureHttpRoute)(instance, kubernetes, route, service);
             }
         },
         async remove() {
-            const ingresses = await instance.networkingApi.listNamespacedIngress(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
-            for (const ingress of ingresses.body.items) {
-                if (ingress.metadata?.name) {
-                    await instance.networkingApi.deleteNamespacedIngress(ingress.metadata.name, kubernetes.namespace);
-                }
-            }
             // HTTPRoutes are a CRD, so they are deleted by name through the generic
             // objectApi rather than listed (a list would error on clusters without the
-            // Gateway API CRDs even when none are declared). Only entries this service
-            // declared as httproute are removed; a missing route (404) is fine.
-            const httpRoutes = kubernetes.ingresses.filter((i) => i.kind === 'httproute' && i.service === service.name);
-            for (const route of httpRoutes) {
+            // Gateway API CRDs even when none are declared). Only the routes this
+            // service declares are removed; a missing route (404) is fine.
+            for (const route of kubernetes.httpRoutes.filter((r) => r.service === service.name)) {
                 try {
                     await instance.objectApi.delete({
                         apiVersion: ensure_http_route_1.HTTP_ROUTE_API_VERSION,
@@ -208,23 +249,32 @@ function kubernetesServiceRuntime(service, kubernetes) {
                     });
                 }
                 catch (e) {
-                    if (statusCodeOf(e) !== 404) {
+                    if ((0, apply_1.statusCodeOf)(e) !== 404) {
                         throw e;
                     }
                 }
             }
-            const services = await instance.coreApi.listNamespacedService(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
-            for (const service of services.body.items) {
+            const services = await instance.coreApi.listNamespacedService({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            for (const service of services.items) {
                 if (service.metadata?.name) {
-                    await instance.coreApi.deleteNamespacedService(service.metadata.name, kubernetes.namespace);
+                    await instance.coreApi.deleteNamespacedService({
+                        name: service.metadata.name,
+                        namespace: kubernetes.namespace,
+                    });
                 }
             }
             await this.stop();
             await (0, remove_persistent_data_1.removePersistentData)(instance, kubernetes, service);
         },
         async currentStateKey() {
-            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
-            const deployment = deployments.body.items[0];
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            const deployment = deployments.items[0];
             return deployment?.metadata?.labels?.['hammerkit.dev/state'] ?? null;
         },
     };

package/dist/planner/work-runtime-local.js

@@ -8,7 +8,9 @@ const tar_1 = require("tar");
 const path_1 = require("path");
 const local_task_1 = require("../executer/local-task");
 const event_cache_1 = require("../executer/event-cache");
+const get_outputs_to_reset_1 = require("./utils/get-outputs-to-reset");
 const find_process_1 = __importDefault(require("find-process"));
+const stream_1 = require("stream");
 function getStateFilename(task) {
     return (0, path_1.join)(task.data.cwd, '.hammerkit', `${task.id()}`);
 }
@@ -56,8 +58,21 @@ function getLocalWorkRuntime(task) {
             const pidFile = getPidFilename(task);
             await environment.file.writeFile(pidFile, `${process.pid}`);
             try {
+                // The record says "the outputs belong to this state key". A run that
+                // fails overwrites outputs, so the previous record goes first, and only
+                // a run that succeeded writes a new one.
+                const stateFile = getStateFilename(task);
+                if (await environment.file.exists(stateFile)) {
+                    await environment.file.remove(stateFile);
+                }
+                for (const generate of (0, get_outputs_to_reset_1.getOutputsToReset)(task.data)) {
+                    await environment.file.remove(generate.path);
+                }
                 await (0, local_task_1.localTask)(task, environment, options);
-                await environment.file.writeFile(getStateFilename(task), options.stateKey);
+                const failed = ['crash', 'error', 'canceled'].includes(options.state.current.type);
+                if (!failed) {
+                    await environment.file.writeFile(stateFile, options.stateKey);
+                }
             }
             finally {
                 if (await environment.file.exists(pidFile)) {
@@ -71,10 +86,16 @@ function getLocalWorkRuntime(task) {
         },
         async currentStateKey(environment) {
             const stateFileName = getStateFilename(task);
-            if (await environment.file.exists(stateFileName)) {
-                return await environment.file.read(stateFileName);
+            if (!(await environment.file.exists(stateFileName))) {
+                return null;
+            }
+            // outputs deleted since the run (rm -rf dist) leave nothing to reuse
+            for (const generate of task.data.generates) {
+                if (!generate.inherited && !(await environment.file.exists(generate.path))) {
+                    return null;
+                }
             }
-            return Promise.resolve(null);
+            return await environment.file.read(stateFileName);
         },
         async remove(environment) {
             for (const generate of task.data.generates) {
@@ -90,15 +111,17 @@ function getLocalWorkRuntime(task) {
 exports.getLocalWorkRuntime = getLocalWorkRuntime;
 async function archiveLocal(environment, task, path) {
     for (const generatedArchive of (0, event_cache_1.getArchivePaths)(task.data, path)) {
-        await environment.file.writeStream(generatedArchive.filename, (0, tar_1.create)({
-            cwd: task.data.cwd,
-            gzip: true,
-        }, [(0, path_1.relative)(task.data.cwd, generatedArchive.path)]));
+        await environment.file.writeStream(generatedArchive.filename, 
+        // tar's stream is a Minipass stream; Readable.from adapts it to a Node one
+        stream_1.Readable.from((0, tar_1.create)({ cwd: task.data.cwd, gzip: true }, [(0, path_1.relative)(task.data.cwd, generatedArchive.path)])));
     }
 }
 async function restoreLocal(environment, task, path) {
     for (const generate of (0, event_cache_1.getArchivePaths)(task, path)) {
         if (await environment.file.exists(generate.filename)) {
+            // a cache hit means exactly the stored outputs: whatever a failed or
+            // older run left in the folder goes first
+            await environment.file.remove(generate.path);
             await (0, tar_1.extract)({
                 file: generate.filename,
                 cwd: task.cwd,

package/dist/planner/work-service-id.js

@@ -3,19 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWorkServiceId = void 0;
 const crypto_1 = require("crypto");
 const work_service_1 = require("./work-service");
+const portable_path_1 = require("./utils/portable-path");
+const plan_work_volume_1 = require("./utils/plan-work-volume");
+// Paths are made project-relative (portablePath) so a service id is identical
+// wherever the project is checked out, like a task id.
 function getWorkServiceId(service) {
+    const portable = (path) => (0, portable_path_1.portablePath)(service.projectRoot, path);
     const jsonData = JSON.stringify((0, work_service_1.isContainerWorkService)(service)
         ? {
-            cwd: service.cwd ?? undefined,
+            cwd: portable(service.cwd),
             image: service.image,
-            volumes: service.volumes.map((v) => `${v.name}:${v.containerPath}`).sort(),
-            src: service.src.map((s) => s.absolutePath).sort(),
+            volumes: service.volumes
+                .map((v) => 
+            // a derived volume name hashes the absolute path, so only an
+            // explicitly declared name participates
+            v.name === (0, plan_work_volume_1.getVolumeName)(v.containerPath)
+                ? portable(v.containerPath)
+                : `${v.name}:${portable(v.containerPath)}`)
+                .sort(),
+            src: service.src.map((s) => portable(s.absolutePath)).sort(),
             mounts: service.mounts.map((m) => m.mount).sort(),
         }
         : {
             context: service.context,
             selector: service.selector,
-            kubeconfig: service.kubeconfig,
+            kubeconfig: portable(service.kubeconfig),
         });
     return (0, crypto_1.createHash)('sha1').update(jsonData).digest('hex');
 }