@stigmer/runner 3.1.3 → 3.1.5

package/src/shared/workspace/__tests__/git-identity.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { execFile } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  AGENT_GIT_AUTHOR_NAME,
+  AGENT_GIT_AUTHOR_EMAIL,
+  AGENT_GIT_IDENTITY_FLAGS,
+  gitCommitAsAgent,
+} from "../git-identity.js";
+
+/**
+ * Environment that approximates the cloud sandbox: no global/system gitconfig,
+ * no GIT_AUTHOR / GIT_COMMITTER variables. In the real sandbox a bare
+ * `git commit` here fails with "Author identity unknown" (hostname-based
+ * auto-detection yields an invalid ident inside the pod); on a developer
+ * machine git may still auto-detect from username + hostname, so these tests
+ * assert the fix's guarantee — the pinned identity always wins — rather than
+ * the environment-dependent failure mode.
+ */
+function identitylessEnv(): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  delete env.GIT_AUTHOR_NAME;
+  delete env.GIT_AUTHOR_EMAIL;
+  delete env.GIT_COMMITTER_NAME;
+  delete env.GIT_COMMITTER_EMAIL;
+  env.GIT_CONFIG_GLOBAL = "/dev/null";
+  env.GIT_CONFIG_SYSTEM = "/dev/null";
+  return env;
+}
+
+function sh(
+  cwd: string,
+  command: string,
+  envOverrides: Record<string, string> = {},
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "sh",
+      ["-c", command],
+      { cwd, env: { ...identitylessEnv(), ...envOverrides } },
+      (err, stdout, stderr) => {
+        if (err) reject(new Error(`Command failed: ${command}\n${stderr || err.message}`));
+        else resolve(stdout);
+      },
+    );
+  });
+}
+
+describe("gitCommitAsAgent (real repo, no ambient identity)", () => {
+  let repo: string;
+
+  beforeEach(async () => {
+    repo = mkdtempSync(join(tmpdir(), "git-identity-test-"));
+    await sh(repo, "git init -q");
+    writeFileSync(join(repo, "notes.md"), "# Project Notes\n");
+    await sh(repo, "git add -A");
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  /**
+   * `user.useConfigOnly=true` (injected via git's config env) forbids the
+   * username+hostname auto-detection that a developer machine would otherwise
+   * fall back to — deterministically reproducing the sandbox condition where
+   * git has no usable identity.
+   */
+  const NO_AUTODETECT_ENV = {
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: "user.useConfigOnly",
+    GIT_CONFIG_VALUE_0: "true",
+  };
+
+  it("reproduces the cloud failure: a bare commit has no identity", async () => {
+    await expect(
+      sh(repo, 'git commit -m "agent changes (1)"', NO_AUTODETECT_ENV),
+    ).rejects.toThrow(/user\.email|user\.name|Author identity unknown|empty ident/);
+  });
+
+  it("the agent identity satisfies git even when auto-detection is forbidden", async () => {
+    await sh(repo, gitCommitAsAgent("agent changes (1)"), NO_AUTODETECT_ENV);
+
+    const author = await sh(repo, "git log -1 --format='%an <%ae>'");
+    expect(author.trim()).toBe(
+      `${AGENT_GIT_AUTHOR_NAME} <${AGENT_GIT_AUTHOR_EMAIL}>`,
+    );
+  });
+
+  it("commits successfully with the agent identity", async () => {
+    await sh(repo, gitCommitAsAgent("agent changes (1)"));
+
+    const author = await sh(repo, "git log -1 --format='%an <%ae>'");
+    expect(author.trim()).toBe(
+      `${AGENT_GIT_AUTHOR_NAME} <${AGENT_GIT_AUTHOR_EMAIL}>`,
+    );
+
+    const committer = await sh(repo, "git log -1 --format='%cn <%ce>'");
+    expect(committer.trim()).toBe(
+      `${AGENT_GIT_AUTHOR_NAME} <${AGENT_GIT_AUTHOR_EMAIL}>`,
+    );
+
+    const message = await sh(repo, "git log -1 --format=%s");
+    expect(message.trim()).toBe("agent changes (1)");
+  });
+
+  it("never mutates the repository's git config", async () => {
+    await sh(repo, gitCommitAsAgent("agent changes (1)"));
+
+    // `git config --local` exits non-zero when the key is unset.
+    await expect(sh(repo, "git config --local user.name")).rejects.toThrow();
+    await expect(sh(repo, "git config --local user.email")).rejects.toThrow();
+  });
+});
+
+describe("AGENT_GIT_IDENTITY_FLAGS", () => {
+  it("pins both name and email via per-command -c flags", () => {
+    expect(AGENT_GIT_IDENTITY_FLAGS).toBe(
+      `-c user.name='${AGENT_GIT_AUTHOR_NAME}' -c user.email='${AGENT_GIT_AUTHOR_EMAIL}'`,
+    );
+  });
+});

package/src/shared/workspace/__tests__/stigmer-link.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, rm, writeFile, readFile, lstat, readlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { FilesystemBackend } from "deepagents";
+
+import {
+  ensureStigmerSymlink,
+  removeStigmerSymlink,
+  STIGMER_LOCAL_STATE_DIR,
+} from "../stigmer-link.js";
+import { LocalWorkspaceBackend } from "../local-backend.js";
+import { injectAttachments } from "../../../activities/execute-deep-agent/attachment-injector.js";
+
+/**
+ * The `.stigmer` symlink is the bridge that makes platform-mounted content
+ * (approved plan, skills, attachment inputs) readable by the agent's file
+ * tools in BOTH harnesses. The lifecycle tests pin the ownership contract
+ * (ensure replaces, remove is symlink-only); the convergence tests pin the
+ * end-to-end physics the native harness depends on: content written through
+ * the platform-routing LocalWorkspaceBackend must be readable at the same
+ * `.stigmer/…` path through a stock deepagents FilesystemBackend rooted at
+ * the workspace — which is exactly what broke when the native harness had no
+ * symlink (the "plan file doesn't exist" bug).
+ */
+describe("stigmer-link", () => {
+  let workspaceDir: string;
+  let platformDir: string;
+
+  beforeEach(async () => {
+    workspaceDir = await mkdtemp(join(tmpdir(), "stigmer-link-ws-"));
+    platformDir = await mkdtemp(join(tmpdir(), "stigmer-link-platform-"));
+  });
+
+  afterEach(async () => {
+    await rm(workspaceDir, { recursive: true, force: true });
+    await rm(platformDir, { recursive: true, force: true });
+  });
+
+  const linkPath = () => join(workspaceDir, STIGMER_LOCAL_STATE_DIR);
+
+  describe("ensureStigmerSymlink", () => {
+    it("creates the workspace symlink pointing at the platform dir", async () => {
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      expect((await lstat(linkPath())).isSymbolicLink()).toBe(true);
+      expect(await readlink(linkPath())).toBe(platformDir);
+    });
+
+    it("is idempotent for a correct existing link", async () => {
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      expect(await readlink(linkPath())).toBe(platformDir);
+    });
+
+    it("re-points a stale link at the current platform dir", async () => {
+      const stalePlatform = await mkdtemp(join(tmpdir(), "stigmer-link-stale-"));
+      try {
+        await ensureStigmerSymlink(workspaceDir, stalePlatform);
+        await ensureStigmerSymlink(workspaceDir, platformDir);
+
+        expect(await readlink(linkPath())).toBe(platformDir);
+      } finally {
+        await rm(stalePlatform, { recursive: true, force: true });
+      }
+    });
+
+    it("replaces a real .stigmer directory (platform owns the name)", async () => {
+      // The ownership sharp edge, pinned deliberately: a non-symlink
+      // `.stigmer` (left behind by an older runner) must never shadow the
+      // platform mount. See the module header for why this is safe.
+      await mkdir(join(linkPath(), "old"), { recursive: true });
+      await writeFile(join(linkPath(), "old", "stale.txt"), "stale");
+
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      expect((await lstat(linkPath())).isSymbolicLink()).toBe(true);
+      expect(await readlink(linkPath())).toBe(platformDir);
+    });
+  });
+
+  describe("removeStigmerSymlink", () => {
+    it("removes the symlink and leaves the platform dir intact", async () => {
+      await writeFile(join(platformDir, "keep.txt"), "keep");
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      await removeStigmerSymlink(workspaceDir);
+
+      await expect(lstat(linkPath())).rejects.toMatchObject({ code: "ENOENT" });
+      expect(await readFile(join(platformDir, "keep.txt"), "utf-8")).toBe("keep");
+    });
+
+    it("leaves a real .stigmer directory untouched (symlink-only removal)", async () => {
+      await mkdir(linkPath(), { recursive: true });
+      await writeFile(join(linkPath(), "user-owned.txt"), "mine");
+
+      await removeStigmerSymlink(workspaceDir);
+
+      expect(await readFile(join(linkPath(), "user-owned.txt"), "utf-8")).toBe("mine");
+    });
+
+    it("is a no-op when no link exists", async () => {
+      await expect(removeStigmerSymlink(workspaceDir)).resolves.toBeUndefined();
+    });
+  });
+
+  // ── Write/read convergence (the native-harness bug, pinned) ─────────
+
+  describe("platform write / agent read convergence", () => {
+    /** Read through the agent's actual file-tool backend. */
+    function agentRead(path: string): Promise<{ content?: string; error?: string }> {
+      const agentBackend = new FilesystemBackend({ rootDir: workspaceDir });
+      return agentBackend.read(path) as Promise<{ content?: string; error?: string }>;
+    }
+
+    it("approved plan injected via injectAttachments is readable by the deepagents backend", async () => {
+      const planFileName = "notes_ab12cd34.plan.md";
+      const planText = "# The Approved Plan\n\nStep 1: do the thing.\n";
+      const uploadPath = join(platformDir, "upload-src.md");
+      await writeFile(uploadPath, planText);
+
+      // Write path: exactly what the build turn does — the attachment is
+      // materialized through the platform-routing backend at the mount path
+      // the implement-plan directive will tell the model to read.
+      const workspaceBackend = new LocalWorkspaceBackend(workspaceDir, platformDir);
+      const injected = await injectAttachments({
+        backend: workspaceBackend,
+        attachments: [{
+          filename: planFileName,
+          storageKey: "",
+          mountPath: `.stigmer/inputs/${planFileName}`,
+          contentType: "text/markdown",
+          extract: false,
+          localPath: uploadPath,
+          $typeName: "ai.stigmer.agentic.agentexecution.v1.Attachment",
+        } as any],
+        storage: undefined,
+        isLocalMode: true,
+      });
+      expect(injected.map((f) => f.path)).toEqual([`.stigmer/inputs/${planFileName}`]);
+
+      // Without the symlink the agent cannot see the plan — the bug this
+      // module fixes for the native harness. Pinned so the link stays
+      // load-bearing in reviewers' and agents' mental models.
+      const before = await agentRead(`.stigmer/inputs/${planFileName}`);
+      expect(before.content ?? "").not.toContain("The Approved Plan");
+
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      const after = await agentRead(`.stigmer/inputs/${planFileName}`);
+      expect(after.error).toBeUndefined();
+      expect(after.content).toContain("The Approved Plan");
+    });
+
+    it("skill written through the platform-routing backend is readable at its prompt location", async () => {
+      // Same physical write the skill-writer performs for
+      // `.stigmer/skills/{name}/SKILL.md` — the path the system prompt tells
+      // the model to read to activate the skill.
+      const workspaceBackend = new LocalWorkspaceBackend(workspaceDir, platformDir);
+      await workspaceBackend.writeFile(
+        ".stigmer/skills/my-skill/SKILL.md",
+        "# My Skill\n\nDo skillful things.\n",
+      );
+
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      const result = await agentRead(".stigmer/skills/my-skill/SKILL.md");
+      expect(result.error).toBeUndefined();
+      expect(result.content).toContain("My Skill");
+    });
+  });
+});

package/src/shared/workspace/git-identity.ts

@@ -0,0 +1,41 @@
+/**
+ * The public git identity for commits the agent authors on the user's behalf.
+ *
+ * Write-back commits (branch/commit/push/PR — see WriteBackCoordinator) land
+ * on real branches in the user's repository, so they carry a dedicated,
+ * recognizable agent identity in every mode — local and cloud alike. This is
+ * deliberate: a commit authored by the agent should never be silently
+ * attributed to whatever identity happens to live in the host's `~/.gitconfig`
+ * (local), and the cloud sandbox has no identity at all, which makes a bare
+ * `git commit` fail with "Author identity unknown".
+ *
+ * Distinct from the *internal* snapshot identity in
+ * `../filereview/git-substrate.ts` (`stigmer-runner <runner@stigmer.local>`):
+ * those commit objects are never on a branch and never pushed — they exist
+ * only to pin trees against GC. This identity is the public-facing one that
+ * appears in `git log`, on GitHub, and in pull requests.
+ */
+export const AGENT_GIT_AUTHOR_NAME = "Stigmer Agent";
+export const AGENT_GIT_AUTHOR_EMAIL = "noreply@stigmer.ai";
+
+/**
+ * `git -c` config flags that pin the agent identity for a single command.
+ *
+ * Per-command `-c` flags (rather than repo-local or global `git config`) keep
+ * the identity deterministic in every environment without mutating the user's
+ * repository config — the same never-mutate reasoning documented on
+ * `SNAPSHOT_IDENTITY_ENV` in `git-substrate.ts`. Env-var injection is not an
+ * option here: `WorkspaceBackend.execute()` takes no env parameter, and
+ * widening that contract for one caller would be a larger change than the
+ * problem deserves.
+ */
+export const AGENT_GIT_IDENTITY_FLAGS =
+  `-c user.name='${AGENT_GIT_AUTHOR_NAME}' -c user.email='${AGENT_GIT_AUTHOR_EMAIL}'`;
+
+/**
+ * Build a `git commit` command that is always authored by the agent identity,
+ * regardless of what identity (if any) the surrounding environment provides.
+ */
+export function gitCommitAsAgent(commitMsg: string): string {
+  return `git ${AGENT_GIT_IDENTITY_FLAGS} commit -m "${commitMsg}"`;
+}

package/src/shared/workspace/local-backend.ts

@@ -6,8 +6,12 @@
  * sandbox) backend will be added in Phase 3.
  *
  * When `platformDir` is provided, paths under `.stigmer/` are
- * transparently routed to the platform directory. The agent sees a
- * unified namespace; the workspace directory is never polluted.
+ * transparently routed to the platform directory, keeping platform files
+ * out of the workspace tree. This routing serves the RUNNER's own I/O
+ * (skill/attachment materialization, `execute` command rewriting) — the
+ * agent's file tools do not go through this backend. Agent-visible reads
+ * of `.stigmer/…` reach the same physical files through the per-turn
+ * workspace symlink instead (see shared/workspace/stigmer-link.ts).
  */
 
 import { execFile } from "node:child_process";

package/src/shared/workspace/stigmer-link.ts

@@ -0,0 +1,97 @@
+/**
+ * The workspace `.stigmer` symlink — the bridge from the session's workspace
+ * to its platform-managed directory (~/.stigmer/sessions/{id}/platform/, see
+ * platform-dir.ts), shared by BOTH harnesses.
+ *
+ * Platform-injected content (skills, attachment inputs, the approved plan)
+ * physically lives in the platform dir, outside the workspace, so a real repo
+ * is never polluted with Stigmer files (issue #173). But the agent reads from
+ * the workspace: the Cursor SDK resolves paths against the workspace CWD, and
+ * the native (deepagents) harness's file tools resolve against a
+ * `FilesystemBackend` rooted at the workspace. The symlink is what makes the
+ * `.stigmer/…` paths those agents are prompted with (skill locations,
+ * `.stigmer/inputs/…` attachments) actually resolve.
+ *
+ * Lifecycle contract (same for both harnesses):
+ * - Created per turn, under the workspace turn lock — the link is a
+ *   working-tree mutation, and re-pointing it while another session's turn is
+ *   running on a shared tree would redirect that turn's reads mid-flight.
+ *   Cursor creates it in its skill/attachment resolvers (which run after lock
+ *   acquisition); the native harness creates it right after acquiring the
+ *   lock (execute-deep-agent/index.ts).
+ * - Removed at turn end ({@link removeStigmerSymlink} in the activity's
+ *   cleanup), so a real repo is left untouched once the turn ends; a
+ *   multi-turn session recreates the link on the next turn.
+ * - {@link ensureStigmerSymlink} is idempotent, so multiple populaters may
+ *   run in any order within a turn.
+ *
+ * OWNERSHIP SHARP EDGE: the platform owns the `.stigmer` name inside a
+ * workspace. {@link ensureStigmerSymlink} REPLACES a real (non-symlink)
+ * `.stigmer` directory it finds there — deliberate, so a directory left
+ * behind by an older runner can never shadow the platform mount. (A user's
+ * own `.stigmer` content is unreachable anyway: the runner's
+ * `LocalWorkspaceBackend` routes every `.stigmer/…` path to the platform
+ * dir.) Turn-end removal is the conservative half: it only ever removes a
+ * SYMLINK.
+ */
+
+import { symlink, readlink, unlink, rm, lstat } from "node:fs/promises";
+import { join } from "node:path";
+
+/** The workspace-visible name of the platform namespace. */
+export const STIGMER_LOCAL_STATE_DIR = ".stigmer";
+
+/**
+ * Ensure the workspace `.stigmer` symlink points to the platform dir.
+ * Idempotent: an existing correct link is kept; a stale link (or a non-link
+ * left behind by an older runner) is replaced.
+ */
+export async function ensureStigmerSymlink(
+  workspaceDir: string,
+  platformDir: string,
+): Promise<void> {
+  const linkPath = join(workspaceDir, STIGMER_LOCAL_STATE_DIR);
+
+  try {
+    const existing = await readlink(linkPath);
+    if (existing === platformDir) return;
+    await unlink(linkPath);
+  } catch (err: any) {
+    if (err.code === "ENOENT") {
+      // No existing symlink
+    } else if (err.code === "EINVAL") {
+      // Exists but is not a symlink — remove the directory
+      await rm(linkPath, { recursive: true, force: true });
+    } else {
+      throw err;
+    }
+  }
+
+  await symlink(platformDir, linkPath, "dir");
+}
+
+/**
+ * Remove the workspace `.stigmer` symlink created by
+ * {@link ensureStigmerSymlink}.
+ *
+ * Called in the activity's cleanup so attaching a real repo leaves no Stigmer
+ * symlink behind once the turn ends (issue #173). Only ever removes a
+ * SYMLINK — a real `.stigmer` directory (which would be the user's own, not
+ * ours) is left untouched. Best-effort.
+ */
+export async function removeStigmerSymlink(workspaceDir: string): Promise<void> {
+  const linkPath = join(workspaceDir, STIGMER_LOCAL_STATE_DIR);
+  try {
+    const stat = await lstat(linkPath);
+    if (stat.isSymbolicLink()) {
+      await unlink(linkPath);
+    }
+  } catch (err: any) {
+    if (err?.code !== "ENOENT") {
+      console.warn(
+        `removeStigmerSymlink: failed to remove ${linkPath} (non-fatal): ` +
+        `${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
+}

package/src/shared/workspace/types.ts

@@ -53,10 +53,12 @@ export class WorkspaceProvisionError extends Error {
  * commands route through the Daytona sandbox proxy.
  *
  * When `platformDir` is set, paths under `.stigmer/` are transparently
- * routed to the platform directory instead of the workspace root. This
- * keeps platform files (skills, inputs) physically separate from the
- * user's workspace while presenting a unified `.stigmer/` namespace to
- * the agent.
+ * routed to the platform directory instead of the workspace root, keeping
+ * platform files (skills, inputs) physically separate from the user's
+ * workspace. The routing covers the RUNNER's own reads/writes through
+ * this interface; the agent's file tools resolve against the workspace
+ * root and see the same files through the per-turn `.stigmer` symlink
+ * (see stigmer-link.ts).
  */
 export interface WorkspaceBackend {
   readonly rootDir: string;

package/dist/activities/execute-cursor/stigmer-link.d.ts

@@ -1,35 +0,0 @@
-/**
- * The workspace `.stigmer` symlink — the Cursor harness's bridge from the
- * user's workspace to the session's platform-managed directory
- * (~/.stigmer/sessions/{id}/platform/, see shared/workspace/platform-dir.ts).
- *
- * The Cursor SDK reads files from the workspace CWD, so platform-injected
- * content (skills, attachment inputs) must be reachable there; the symlink is
- * how, without ever writing platform files into the user's repo (issue #173).
- * This mechanism is deliberately harness-local: the native harness routes
- * `.stigmer/` paths through its WorkspaceBackend instead and never symlinks.
- *
- * Both resolvers that populate the platform dir (skills, attachments) call
- * {@link ensureStigmerSymlink}; it is idempotent, so either may run first and
- * an agent with only one kind of content still gets the link. The activity's
- * cleanup calls {@link removeStigmerSymlink} so a real repo is left untouched
- * once the turn ends; a multi-turn session recreates the link on the next turn.
- */
-/** The workspace-visible name of the platform namespace. */
-export declare const STIGMER_LOCAL_STATE_DIR = ".stigmer";
-/**
- * Ensure the workspace `.stigmer` symlink points to the platform dir.
- * Idempotent: an existing correct link is kept; a stale link (or a non-link
- * left behind by an older runner) is replaced.
- */
-export declare function ensureStigmerSymlink(workspaceDir: string, platformDir: string): Promise<void>;
-/**
- * Remove the workspace `.stigmer` symlink created by
- * {@link ensureStigmerSymlink}.
- *
- * Called in the activity's finally so attaching a real repo leaves no Stigmer
- * symlink behind once the turn ends (issue #173). Only ever removes a
- * SYMLINK — a real `.stigmer` directory (which would be the user's own, not
- * ours) is left untouched. Best-effort.
- */
-export declare function removeStigmerSymlink(workspaceDir: string): Promise<void>;

package/dist/activities/execute-cursor/stigmer-link.js

@@ -1,73 +0,0 @@
-/**
- * The workspace `.stigmer` symlink — the Cursor harness's bridge from the
- * user's workspace to the session's platform-managed directory
- * (~/.stigmer/sessions/{id}/platform/, see shared/workspace/platform-dir.ts).
- *
- * The Cursor SDK reads files from the workspace CWD, so platform-injected
- * content (skills, attachment inputs) must be reachable there; the symlink is
- * how, without ever writing platform files into the user's repo (issue #173).
- * This mechanism is deliberately harness-local: the native harness routes
- * `.stigmer/` paths through its WorkspaceBackend instead and never symlinks.
- *
- * Both resolvers that populate the platform dir (skills, attachments) call
- * {@link ensureStigmerSymlink}; it is idempotent, so either may run first and
- * an agent with only one kind of content still gets the link. The activity's
- * cleanup calls {@link removeStigmerSymlink} so a real repo is left untouched
- * once the turn ends; a multi-turn session recreates the link on the next turn.
- */
-import { symlink, readlink, unlink, rm, lstat } from "node:fs/promises";
-import { join } from "node:path";
-/** The workspace-visible name of the platform namespace. */
-export const STIGMER_LOCAL_STATE_DIR = ".stigmer";
-/**
- * Ensure the workspace `.stigmer` symlink points to the platform dir.
- * Idempotent: an existing correct link is kept; a stale link (or a non-link
- * left behind by an older runner) is replaced.
- */
-export async function ensureStigmerSymlink(workspaceDir, platformDir) {
-    const linkPath = join(workspaceDir, STIGMER_LOCAL_STATE_DIR);
-    try {
-        const existing = await readlink(linkPath);
-        if (existing === platformDir)
-            return;
-        await unlink(linkPath);
-    }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            // No existing symlink
-        }
-        else if (err.code === "EINVAL") {
-            // Exists but is not a symlink — remove the directory
-            await rm(linkPath, { recursive: true, force: true });
-        }
-        else {
-            throw err;
-        }
-    }
-    await symlink(platformDir, linkPath, "dir");
-}
-/**
- * Remove the workspace `.stigmer` symlink created by
- * {@link ensureStigmerSymlink}.
- *
- * Called in the activity's finally so attaching a real repo leaves no Stigmer
- * symlink behind once the turn ends (issue #173). Only ever removes a
- * SYMLINK — a real `.stigmer` directory (which would be the user's own, not
- * ours) is left untouched. Best-effort.
- */
-export async function removeStigmerSymlink(workspaceDir) {
-    const linkPath = join(workspaceDir, STIGMER_LOCAL_STATE_DIR);
-    try {
-        const stat = await lstat(linkPath);
-        if (stat.isSymbolicLink()) {
-            await unlink(linkPath);
-        }
-    }
-    catch (err) {
-        if (err?.code !== "ENOENT") {
-            console.warn(`removeStigmerSymlink: failed to remove ${linkPath} (non-fatal): ` +
-                `${err instanceof Error ? err.message : err}`);
-        }
-    }
-}
-//# sourceMappingURL=stigmer-link.js.map

package/dist/activities/execute-cursor/stigmer-link.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stigmer-link.js","sourceRoot":"","sources":["../../../src/activities/execute-cursor/stigmer-link.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,4DAA4D;AAC5D,MAAM,CAAC,MAAM,uBAAuB,GAAG,UAAU,CAAC;AAElD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,YAAoB,EACpB,WAAmB;IAEnB,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAC;IAE7D,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC1C,IAAI,QAAQ,KAAK,WAAW;YAAE,OAAO;QACrC,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;IACzB,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC1B,sBAAsB;QACxB,CAAC;aAAM,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACjC,qDAAqD;YACrD,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACvD,CAAC;aAAM,CAAC;YACN,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAED,MAAM,OAAO,CAAC,WAAW,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,YAAoB;IAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAC;IAC7D,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,QAAQ,CAAC,CAAC;QACnC,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YAC1B,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,IAAI,GAAG,EAAE,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3B,OAAO,CAAC,IAAI,CACV,0CAA0C,QAAQ,gBAAgB;gBAClE,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAC9C,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/src/activities/execute-cursor/stigmer-link.ts

@@ -1,78 +0,0 @@
-/**
- * The workspace `.stigmer` symlink — the Cursor harness's bridge from the
- * user's workspace to the session's platform-managed directory
- * (~/.stigmer/sessions/{id}/platform/, see shared/workspace/platform-dir.ts).
- *
- * The Cursor SDK reads files from the workspace CWD, so platform-injected
- * content (skills, attachment inputs) must be reachable there; the symlink is
- * how, without ever writing platform files into the user's repo (issue #173).
- * This mechanism is deliberately harness-local: the native harness routes
- * `.stigmer/` paths through its WorkspaceBackend instead and never symlinks.
- *
- * Both resolvers that populate the platform dir (skills, attachments) call
- * {@link ensureStigmerSymlink}; it is idempotent, so either may run first and
- * an agent with only one kind of content still gets the link. The activity's
- * cleanup calls {@link removeStigmerSymlink} so a real repo is left untouched
- * once the turn ends; a multi-turn session recreates the link on the next turn.
- */
-
-import { symlink, readlink, unlink, rm, lstat } from "node:fs/promises";
-import { join } from "node:path";
-
-/** The workspace-visible name of the platform namespace. */
-export const STIGMER_LOCAL_STATE_DIR = ".stigmer";
-
-/**
- * Ensure the workspace `.stigmer` symlink points to the platform dir.
- * Idempotent: an existing correct link is kept; a stale link (or a non-link
- * left behind by an older runner) is replaced.
- */
-export async function ensureStigmerSymlink(
-  workspaceDir: string,
-  platformDir: string,
-): Promise<void> {
-  const linkPath = join(workspaceDir, STIGMER_LOCAL_STATE_DIR);
-
-  try {
-    const existing = await readlink(linkPath);
-    if (existing === platformDir) return;
-    await unlink(linkPath);
-  } catch (err: any) {
-    if (err.code === "ENOENT") {
-      // No existing symlink
-    } else if (err.code === "EINVAL") {
-      // Exists but is not a symlink — remove the directory
-      await rm(linkPath, { recursive: true, force: true });
-    } else {
-      throw err;
-    }
-  }
-
-  await symlink(platformDir, linkPath, "dir");
-}
-
-/**
- * Remove the workspace `.stigmer` symlink created by
- * {@link ensureStigmerSymlink}.
- *
- * Called in the activity's finally so attaching a real repo leaves no Stigmer
- * symlink behind once the turn ends (issue #173). Only ever removes a
- * SYMLINK — a real `.stigmer` directory (which would be the user's own, not
- * ours) is left untouched. Best-effort.
- */
-export async function removeStigmerSymlink(workspaceDir: string): Promise<void> {
-  const linkPath = join(workspaceDir, STIGMER_LOCAL_STATE_DIR);
-  try {
-    const stat = await lstat(linkPath);
-    if (stat.isSymbolicLink()) {
-      await unlink(linkPath);
-    }
-  } catch (err: any) {
-    if (err?.code !== "ENOENT") {
-      console.warn(
-        `removeStigmerSymlink: failed to remove ${linkPath} (non-fatal): ` +
-        `${err instanceof Error ? err.message : err}`,
-      );
-    }
-  }
-}