@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/dist/src/worker-workspaces.js

@@ -0,0 +1,274 @@
+import { randomUUID } from 'node:crypto';
+import { readTree } from './workspaces.js';
+import { repositoryPath } from './repository-snapshots.js';
+import { canonical, digest, ServiceError } from './protocol.js';
+import { workspaceDiff } from './workspace-diff.js';
+/** Drafts are private owned copies. Integration reuses the hash-bound workspace journal. */
+export class WorkerWorkspaces {
+    store;
+    workspaces;
+    repositories;
+    artifacts;
+    coding;
+    children;
+    constructor(store, workspaces, repositories, artifacts, coding, children) {
+        this.store = store;
+        this.workspaces = workspaces;
+        this.repositories = repositories;
+        this.artifacts = artifacts;
+        this.coding = coding;
+        this.children = children;
+    }
+    execution() {
+        const executor = this.coding.executor;
+        if (!executor?.profileDigest ||
+            !executor.engineId ||
+            (executor.evidence.probe !== 'passed' && executor.evidence.fixture !== true))
+            throw new ServiceError('executor_unavailable', 'Writing specialists require a configured execution boundary');
+        return {
+            profile_digest: executor.profileDigest,
+            engine_id: executor.engineId,
+            evidence: executor.evidence.fixture === true ? 'fixture' : 'proven',
+        };
+    }
+    prepare(session, repository) {
+        const execution = this.execution();
+        const tree = JSON.parse(this.artifacts.read(repository.artifact_id));
+        if (digest(tree) !== repository.digest)
+            throw new ServiceError('artifact_corrupt', 'Worker baseline digest changed');
+        const workspace = this.workspaces.cloneSnapshot(session, tree);
+        return {
+            workspace_id: workspace.id,
+            baseline_artifact: repository.artifact_id,
+            digest: repository.digest,
+            execution,
+        };
+    }
+    assert(binding) {
+        const scope = binding.isolation;
+        if (!scope || canonical(scope.execution) !== canonical(this.execution()))
+            throw new ServiceError('worker_binding_changed', 'Worker execution environment changed');
+        const workspace = this.workspaces.get(binding.session_id);
+        if (workspace.id !== scope.workspace_id ||
+            scope.digest !== binding.repository?.digest ||
+            scope.baseline_artifact !== binding.repository?.artifact_id)
+            throw new ServiceError('worker_binding_changed', 'Worker workspace ownership changed');
+        this.coding.assertSafe(binding.session_id);
+    }
+    settled(parent, id, complete = true) {
+        const child = this.children.inspect(parent, id), binding = child.worker.binding;
+        if (!binding.isolation ||
+            (binding.external && !this.children.external?.stopped(child.id)) ||
+            (complete ? child.state !== 'completed' : child.state === 'accepted') ||
+            this.store.db
+                .prepare("SELECT 1 FROM workers WHERE session_id=? AND state!='exited'")
+                .get(child.child_session) ||
+            this.store.db
+                .prepare("SELECT 1 FROM command_runs WHERE session_id=? AND state NOT IN ('succeeded','failed','cancelled','timed_out','output_limited','interrupted')")
+                .get(child.child_session))
+            throw new ServiceError('worker_not_settled', 'Wait for the owned worker and commands to stop before inspecting its proposal');
+        this.assert(binding);
+        return { child, binding };
+    }
+    proposal(parent, id, offset) {
+        const { child, binding } = this.settled(parent, id, false);
+        const workspace = this.workspaces.verify(child.child_session), baseline = this.repositories.tree(binding), current = readTree(workspace.root);
+        if (digest(current) !== workspace.digest)
+            throw new ServiceError('workspace_changed', 'Worker draft changed during inspection');
+        const changes = [...new Set([...Object.keys(baseline), ...Object.keys(current)])]
+            .sort()
+            .filter((path) => digest(baseline[path] ?? null) !== digest(current[path] ?? null))
+            .map((path) => {
+            repositoryPath(path);
+            return { path, before: baseline[path] ?? null, after: current[path] ?? null };
+        });
+        const patch = {
+            schema_version: 1,
+            worker_id: binding.worker_id,
+            child_id: id,
+            worker_state: child.state,
+            baseline_digest: binding.repository.digest,
+            draft_digest: workspace.digest,
+            changes,
+        };
+        return {
+            ...patch,
+            changes: offset === undefined ? changes : changes.slice(offset, offset + 1),
+            diff: (offset === undefined ? changes : changes.slice(offset, offset + 1)).map(workspaceDiff),
+            next_offset: offset !== undefined && offset + 1 < changes.length ? offset + 1 : null,
+            patch_digest: digest(patch),
+            verified_success: false,
+        };
+    }
+    integrate(parent, childId, request, revision, rootDigest, patchDigest, authorize) {
+        let fresh = false;
+        const receipt = this.store.request('local-operator', request, { kind: 'worker-integrate', parent, childId, revision, rootDigest, patchDigest }, () => {
+            authorize();
+            const task = this.store.db
+                .prepare('SELECT state FROM durable_tasks WHERE session_id=?')
+                .get(parent);
+            if (task?.state === 'cancelled')
+                throw new ServiceError('task_settled', 'Task cancellation revoked integration authority');
+            const { child, binding } = this.settled(parent, childId);
+            this.assertRootIdle(parent);
+            if (this.store.db.prepare('SELECT 1 FROM worker_integrations WHERE child_id=?').get(childId))
+                throw new ServiceError('integration_exists', 'This draft already has an integration intent; inspect its receipt');
+            const proposal = this.proposal(parent, childId);
+            if (proposal.patch_digest !== patchDigest)
+                throw new ServiceError('proposal_changed', 'Review the exact current worker proposal');
+            if (this.store.db
+                .prepare("SELECT 1 FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running')")
+                .get(parent))
+                throw new ServiceError('task_busy', 'Pause root work before integration');
+            const workspace = this.workspaces.verify(parent);
+            if (workspace.revision !== revision || workspace.digest !== rootDigest)
+                throw new ServiceError('workspace_changed', 'Root workspace changed since review');
+            const before = readTree(workspace.root), after = { ...before };
+            for (const change of proposal.changes) {
+                if (digest(before[change.path] ?? null) !== digest(change.before))
+                    throw new ServiceError('integration_conflict', 'Root and worker both changed ' + change.path);
+                if (change.after)
+                    after[change.path] = change.after;
+                else
+                    delete after[change.path];
+            }
+            const artifact = this.artifacts.prepare(parent, JSON.stringify(after));
+            artifact.commit();
+            const id = randomUUID();
+            this.store.db
+                .prepare("INSERT INTO worker_integrations VALUES (?,?,?,?,?,?,?,?,'prepared',NULL,?,1)")
+                .run(id, parent, child.id, binding.worker_id, patchDigest, workspace.revision, workspace.digest, artifact.id, 'worker-integration:' + id);
+            this.store.event(parent, 'worker.integration_prepared', {
+                integration_id: id,
+                child_id: childId,
+                patch_digest: patchDigest,
+                before_digest: workspace.digest,
+                after_digest: digest(after),
+            });
+            fresh = true;
+            return { id };
+        });
+        if (fresh)
+            this.apply(receipt.id, authorize);
+        return this.inspect(receipt.id);
+    }
+    apply(id, authorize) {
+        const row = this.row(id), parent = String(row.parent_session), workspace = this.workspaces.verify(parent), before = readTree(workspace.root), after = JSON.parse(this.artifacts.read(String(row.after_artifact)));
+        authorize();
+        this.assertRootIdle(parent);
+        if (workspace.revision !== row.before_revision || digest(before) !== row.before_digest)
+            throw new ServiceError('workspace_changed', 'Root changed after integration intent; no overwrite was performed');
+        this.workspaces.replace(parent, String(row.mutation_key), String(row.patch_digest), Number(row.before_revision), before, after);
+        this.reconcile(id);
+    }
+    resolve(id, request, revision, rootDigest, authorize) {
+        let fresh = false;
+        this.store.request('local-operator', request, { kind: 'integration-resolve', id, revision, rootDigest }, () => {
+            authorize();
+            const row = this.row(id), parent = String(row.parent_session), workspace = this.workspaces.verify(parent);
+            this.assertRootIdle(parent);
+            const task = this.store.db
+                .prepare('SELECT state FROM durable_tasks WHERE session_id=?')
+                .get(parent);
+            if (task?.state === 'cancelled')
+                throw new ServiceError('task_settled', 'Task cancellation revoked integration authority');
+            if (!['prepared', 'needs_resolution'].includes(String(row.state)) ||
+                Number(row.generation) >= 8)
+                throw new ServiceError('integration_settled', 'Integration is applied or its resolution limit was reached');
+            if (workspace.revision !== revision ||
+                workspace.digest !== rootDigest ||
+                revision !== row.before_revision ||
+                rootDigest !== row.before_digest)
+                throw new ServiceError('workspace_changed', 'Resolution requires the exact unchanged pre-integration root');
+            const mutation = this.store.db
+                .prepare('SELECT state FROM workspace_mutations WHERE workspace_id=? AND request_key=?')
+                .get(workspace.id, String(row.mutation_key));
+            if (mutation && mutation.state !== 'failed_definite')
+                throw new ServiceError('integration_uncertain', 'Reconcile the existing workspace mutation before a new apply');
+            const generation = Number(row.generation) + 1, key = 'worker-integration:' + id + ':' + generation;
+            this.store.db
+                .prepare("UPDATE worker_integrations SET state='prepared',mutation_id=NULL,mutation_key=?,generation=? WHERE id=?")
+                .run(key, generation, id);
+            this.store.event(parent, 'worker.integration_resolution_admitted', {
+                integration_id: id,
+                generation,
+                mutation_key: key,
+                request_id: request,
+            });
+            fresh = true;
+            return { id };
+        });
+        if (fresh)
+            this.apply(id, authorize);
+        return this.inspect(id);
+    }
+    owner(id) {
+        return String(this.row(id).parent_session);
+    }
+    assertRootIdle(parent) {
+        if (this.store.db
+            .prepare("SELECT 1 FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running')")
+            .get(parent) ||
+            this.store.db
+                .prepare("SELECT 1 FROM compactions WHERE session_id=? AND state='running'")
+                .get(parent))
+            throw new ServiceError('task_busy', 'Pause root work before integration');
+    }
+    row(id) {
+        const row = this.store.db.prepare('SELECT * FROM worker_integrations WHERE id=?').get(id);
+        if (!row)
+            throw new ServiceError('not_found', 'Integration receipt not found', 404);
+        return row;
+    }
+    inspect(id) {
+        const row = this.row(id), workspace = this.workspaces.get(String(row.parent_session)), after = JSON.parse(this.artifacts.read(String(row.after_artifact)));
+        let current = false;
+        try {
+            current =
+                row.state === 'applied' &&
+                    this.workspaces.verify(String(row.parent_session)).digest === digest(after);
+        }
+        catch { }
+        return { ...row, after_digest: digest(after), current, verified_success: false };
+    }
+    reconcile(id) {
+        const row = this.row(id);
+        if (row.state === 'applied')
+            return;
+        const workspace = this.workspaces.get(String(row.parent_session)), after = JSON.parse(this.artifacts.read(String(row.after_artifact)));
+        const mutation = this.store.db
+            .prepare('SELECT * FROM workspace_mutations WHERE workspace_id=? AND request_key=?')
+            .get(workspace.id, String(row.mutation_key));
+        const applied = mutation?.state === 'applied' && mutation.after_digest === digest(after);
+        this.store.transaction(() => {
+            this.store.db
+                .prepare('UPDATE worker_integrations SET state=?,mutation_id=? WHERE id=?')
+                .run(applied ? 'applied' : 'needs_resolution', mutation ? String(mutation.id) : null, id);
+            this.store.event(String(row.parent_session), 'worker.integration_reconciled', {
+                integration_id: id,
+                state: applied ? 'applied' : 'needs_resolution',
+                mutation_id: mutation?.id ?? null,
+            });
+        });
+    }
+    recover() {
+        for (const row of this.store.db
+            .prepare("SELECT id FROM worker_integrations WHERE state='prepared'")
+            .all())
+            this.reconcile(String(row.id));
+    }
+    assertStepReview(task, step) {
+        const row = this.store.db
+            .prepare('SELECT c.id,b.binding FROM task_steps s JOIN child_tasks c ON c.child_attempt=s.attempt_id JOIN child_workers b ON b.child_id=c.id WHERE s.task_id=? AND s.id=?')
+            .get(task, step);
+        if (!row)
+            return;
+        const binding = JSON.parse(String(row.binding));
+        if (!binding.tools.includes('salaam_files'))
+            return;
+        if (!this.store.db
+            .prepare("SELECT 1 FROM worker_integrations WHERE child_id=? AND state='applied'")
+            .get(String(row.id)))
+            throw new ServiceError('integration_required', 'Integrate the exact writing-worker proposal before step verification or completion');
+    }
+}

package/dist/src/workspaces.js

@@ -220,7 +220,7 @@ export class Workspaces {
         if (digest(readTree(root)) !== digest(tree))
             throw new ServiceError('workspace_conflict', 'Occurrence workspace changed before publication');
         const baseline = this.artifacts.prepare(session, JSON.stringify(tree));
-        this.store.transaction(() => {
+        const publish = () => {
             baseline.commit();
             this.store.db
                 .prepare("INSERT INTO workspaces VALUES (?,?,?,?,0,?,?,'ready')")
@@ -231,7 +231,11 @@ export class Workspaces {
                 digest: digest(tree),
                 cloned: true,
             });
-        });
+        };
+        if (this.store.db.isTransaction)
+            publish();
+        else
+            this.store.transaction(publish);
         return this.get(session);
     }
     inspect(session) {

package/harness-runtime/codex-pins.json

@@ -0,0 +1,10 @@
+{
+  "linux-arm64": {
+    "url": "https://registry.npmjs.org/@openai/codex/-/codex-0.163.0-linux-arm64.tgz",
+    "integrity": "IH2/R+4OarjGvsAf1ll3fdyLwrPgYLl3uzp6u9CyD9sj2Lw+ViDSe3QBZVHdcHJs0eIiZFg6Wprcuy4CRZaUGw=="
+  },
+  "linux-x64": {
+    "url": "https://registry.npmjs.org/@openai/codex/-/codex-0.163.0-linux-x64.tgz",
+    "integrity": "uwRaOsrYogLQhcxAM/GoeWrw0QIWEMRo7c9gM8sKAviVkZQHlu9kRLJ5PkufbV+ABGjyZgIwiFdJ0LCJ0N6e8w=="
+  }
+}