@hasna/todos 0.11.43 → 0.11.44

package/dist/mcp/index.js

@@ -10014,6 +10014,295 @@ var init_builtin_templates = __esm(() => {
   ];
 });
 
+// src/lib/environment-snapshots.ts
+var exports_environment_snapshots = {};
+__export(exports_environment_snapshots, {
+  writeEnvironmentSnapshot: () => writeEnvironmentSnapshot,
+  recordEnvironmentSnapshot: () => recordEnvironmentSnapshot,
+  readEnvironmentSnapshot: () => readEnvironmentSnapshot,
+  compareEnvironmentSnapshots: () => compareEnvironmentSnapshots,
+  compareEnvironmentSnapshotFiles: () => compareEnvironmentSnapshotFiles,
+  captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
+});
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync6 } from "fs";
+import { hostname, platform, arch } from "os";
+import { dirname as dirname7, join as join7, resolve as resolve9 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+function sha2563(value) {
+  return createHash5("sha256").update(value).digest("hex");
+}
+function fileRecord(root, relativePath) {
+  const path = join7(root, relativePath);
+  if (!existsSync8(path))
+    return null;
+  const stat = statSync6(path);
+  if (!stat.isFile())
+    return null;
+  const content = readFileSync6(path);
+  return { path: relativePath, sha256: sha2563(content), size_bytes: content.length };
+}
+function manifestRecord(root, relativePath) {
+  const base = fileRecord(root, relativePath);
+  if (!base)
+    return null;
+  const parsed = readJsonFile(join7(root, relativePath));
+  if (!parsed)
+    return { ...base, redacted: {} };
+  const redacted = redactValue({
+    name: parsed["name"] ?? null,
+    version: parsed["version"] ?? null,
+    packageManager: parsed["packageManager"] ?? null,
+    scripts: parsed["scripts"] ?? {},
+    dependencies: parsed["dependencies"] ?? {},
+    devDependencies: parsed["devDependencies"] ?? {},
+    peerDependencies: parsed["peerDependencies"] ?? {},
+    optionalDependencies: parsed["optionalDependencies"] ?? {}
+  });
+  return { ...base, redacted };
+}
+function runLocalCommand(root, args) {
+  const result = Bun.spawnSync({
+    cmd: args,
+    cwd: root,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { PATH: process.env["PATH"] || "" }
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: redactEvidenceText(result.stdout.toString("utf8").trim()),
+    stderr: redactEvidenceText(result.stderr.toString("utf8").trim())
+  };
+}
+function summarizeGitStatus(lines) {
+  const summary = { added: 0, modified: 0, deleted: 0, renamed: 0, untracked: 0 };
+  for (const line of lines) {
+    if (line.startsWith("??"))
+      summary.untracked += 1;
+    else if (line.includes("R"))
+      summary.renamed += 1;
+    else if (line.includes("D"))
+      summary.deleted += 1;
+    else if (line.includes("A"))
+      summary.added += 1;
+    else if (line.includes("M"))
+      summary.modified += 1;
+  }
+  return summary;
+}
+function captureGit(root, warnings) {
+  const inside = runLocalCommand(root, ["git", "rev-parse", "--is-inside-work-tree"]);
+  if (inside.exitCode !== 0 || inside.stdout !== "true") {
+    return { present: false, branch: null, commit: null, is_dirty: false, status_porcelain: [], status_summary: summarizeGitStatus([]) };
+  }
+  const branch = runLocalCommand(root, ["git", "branch", "--show-current"]);
+  const commit = runLocalCommand(root, ["git", "rev-parse", "HEAD"]);
+  const status = runLocalCommand(root, ["git", "status", "--porcelain=v1"]);
+  if (commit.exitCode !== 0)
+    warnings.push(`git commit unavailable: ${commit.stderr || commit.stdout || "unknown error"}`);
+  if (status.exitCode !== 0)
+    warnings.push(`git status unavailable: ${status.stderr || status.stdout || "unknown error"}`);
+  const lines = status.stdout ? status.stdout.split(/\r?\n/).filter(Boolean) : [];
+  return {
+    present: true,
+    branch: branch.stdout || null,
+    commit: commit.stdout || null,
+    is_dirty: lines.length > 0,
+    status_porcelain: lines,
+    status_summary: summarizeGitStatus(lines)
+  };
+}
+function packageManager(env, lockfiles) {
+  const userAgent = (env["npm_config_user_agent"] || "").toLowerCase();
+  if (userAgent.includes("bun"))
+    return "bun";
+  if (lockfiles.some((file) => file.path.startsWith("bun.lock")))
+    return "bun";
+  if (userAgent.includes("npm") || lockfiles.some((file) => file.path.includes("package-lock")))
+    return "npm";
+  return "unknown";
+}
+function isSecretEnvKey(key) {
+  return /api[_-]?key|token|secret|password|credential|private|session|cookie/i.test(key);
+}
+function commandEnv(env, includeValues) {
+  const keys = Object.keys(env).sort();
+  const interesting = keys.filter((key) => isSecretEnvKey(key) || ["CI", "NODE_ENV", "BUN_ENV", "SHELL", "TERM", "PATH", "PWD", "USER", "npm_config_user_agent"].includes(key) || key.startsWith("TODOS_") || key.startsWith("BUN_"));
+  const redactedKeys = interesting.filter(isSecretEnvKey);
+  const values = includeValues ? Object.fromEntries(interesting.map((key) => [key, isSecretEnvKey(key) ? "[REDACTED]" : redactEvidenceText(String(env[key] ?? ""))])) : null;
+  return {
+    command: null,
+    env_keys: interesting,
+    env: values,
+    redacted_keys: redactedKeys
+  };
+}
+function defaultSnapshotDir() {
+  const dbPath = getDatabasePath();
+  if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
+    return join7(tmpdir2(), "hasna-todos", "environment-snapshots");
+  return join7(dirname7(resolve9(dbPath)), "environment-snapshots");
+}
+function snapshotWithId(snapshot) {
+  const digest = sha2563(JSON.stringify(snapshot)).slice(0, 24);
+  return { id: `env_${digest}`, ...snapshot };
+}
+function captureEnvironmentSnapshot(input = {}) {
+  const root = resolve9(input.root || process.cwd());
+  const env = input.env || process.env;
+  const warnings = [];
+  const manifests = MANIFEST_FILES.map((file) => manifestRecord(root, file)).filter((file) => Boolean(file));
+  const lockfiles = LOCKFILES.map((file) => fileRecord(root, file)).filter((file) => Boolean(file));
+  const configHashes = CONFIG_FILES.map((file) => fileRecord(root, file)).filter((file) => Boolean(file));
+  const commandMetadata = commandEnv(env, Boolean(input.include_env_values));
+  commandMetadata.command = input.command ? redactEvidenceText(input.command) : null;
+  if (manifests.length === 0)
+    warnings.push("no package manifest found");
+  if (lockfiles.length === 0)
+    warnings.push("no package lockfile found");
+  return snapshotWithId({
+    schema_version: 1,
+    captured_at: input.now ? new Date(input.now).toISOString() : new Date().toISOString(),
+    root,
+    machine: { hostname: hostname(), platform: platform(), arch: arch() },
+    target: {
+      task_id: input.task_id ?? null,
+      run_id: input.run_id ?? null,
+      agent_id: input.agent_id ?? null
+    },
+    runtime: {
+      bun: Bun.version || null,
+      node: process.version,
+      executable: process.execPath
+    },
+    package_manager: {
+      manager: packageManager(env, lockfiles),
+      user_agent: env["npm_config_user_agent"] ? redactEvidenceText(env["npm_config_user_agent"]) : null,
+      manifests,
+      lockfiles
+    },
+    git: captureGit(root, warnings),
+    config_hashes: configHashes,
+    command_env: commandMetadata,
+    warnings
+  });
+}
+function writeEnvironmentSnapshot(snapshot, outputPath) {
+  const path = outputPath ? resolve9(outputPath) : join7(defaultSnapshotDir(), `${snapshot.id}.json`);
+  ensureDir2(dirname7(path));
+  writeJsonFile(path, snapshot);
+  return path;
+}
+function readEnvironmentSnapshot(path) {
+  const snapshot = readJsonFile(resolve9(path));
+  if (!snapshot || snapshot.schema_version !== 1 || typeof snapshot.id !== "string") {
+    throw new Error(`Invalid environment snapshot: ${path}`);
+  }
+  return snapshot;
+}
+function recordEnvironmentSnapshot(input = {}, db) {
+  let taskId = input.task_id;
+  let runId = input.run_id;
+  const needsDatabase = Boolean(taskId || runId);
+  const d = needsDatabase ? db || getDatabase() : null;
+  if (runId) {
+    runId = resolveTaskRunId(runId, d);
+    const run = getTaskRun(runId, d);
+    if (!run)
+      throw new Error(`Run not found: ${input.run_id}`);
+    taskId = taskId || run.task_id;
+  }
+  if (taskId && d) {
+    taskId = resolvePartialId(d, "tasks", taskId) || taskId;
+    if (!getTask(taskId, d))
+      throw new Error(`Task not found: ${taskId}`);
+  }
+  const snapshot = captureEnvironmentSnapshot({ ...input, task_id: taskId, run_id: runId });
+  const outputPath = writeEnvironmentSnapshot(snapshot, input.output_path);
+  let taskVerificationId = null;
+  let runArtifactId = null;
+  if (runId) {
+    const artifact = addTaskRunArtifact({
+      run_id: runId,
+      path: outputPath,
+      artifact_type: "environment_snapshot",
+      description: "Reproducible local environment snapshot",
+      metadata: { environment_snapshot_id: snapshot.id, schema_version: snapshot.schema_version },
+      store_content: input.store_content ?? true,
+      agent_id: input.agent_id
+    }, d);
+    runArtifactId = artifact.id;
+  } else if (taskId) {
+    const verification = addTaskVerification({
+      task_id: taskId,
+      command: input.command || "capture environment snapshot",
+      status: "unknown",
+      output_summary: `environment snapshot ${snapshot.id}`,
+      artifact_path: outputPath,
+      agent_id: input.agent_id,
+      run_at: snapshot.captured_at
+    }, d);
+    taskVerificationId = verification.id;
+  }
+  return { snapshot, output_path: outputPath, task_verification_id: taskVerificationId, run_artifact_id: runArtifactId };
+}
+function keyed(files) {
+  return new Map(files.map((file) => [file.path, file]));
+}
+function diffFiles(left, right) {
+  const leftMap = keyed(left);
+  const rightMap = keyed(right);
+  const paths = [...new Set([...leftMap.keys(), ...rightMap.keys()])].sort((a, b) => a.localeCompare(b));
+  return paths.map((path) => ({ path, left_sha256: leftMap.get(path)?.sha256 ?? null, right_sha256: rightMap.get(path)?.sha256 ?? null })).filter((entry) => entry.left_sha256 !== entry.right_sha256);
+}
+function compareEnvironmentSnapshots(left, right) {
+  const warnings = [];
+  if (left.schema_version !== right.schema_version)
+    warnings.push("snapshot schema versions differ");
+  return {
+    schema_version: 1,
+    left_id: left.id,
+    right_id: right.id,
+    same_root: left.root === right.root,
+    same_machine: left.machine.hostname === right.machine.hostname && left.machine.platform === right.machine.platform && left.machine.arch === right.machine.arch,
+    same_runtime: left.runtime.bun === right.runtime.bun && left.runtime.node === right.runtime.node,
+    same_git_commit: left.git.commit === right.git.commit,
+    dirty_state_changed: left.git.is_dirty !== right.git.is_dirty,
+    changed_config_hashes: diffFiles(left.config_hashes, right.config_hashes),
+    changed_lockfiles: diffFiles(left.package_manager.lockfiles, right.package_manager.lockfiles),
+    changed_manifests: diffFiles(left.package_manager.manifests, right.package_manager.manifests),
+    warnings
+  };
+}
+function compareEnvironmentSnapshotFiles(leftPath, rightPath) {
+  return compareEnvironmentSnapshots(readEnvironmentSnapshot(leftPath), readEnvironmentSnapshot(rightPath));
+}
+var MANIFEST_FILES, LOCKFILES, CONFIG_FILES;
+var init_environment_snapshots = __esm(() => {
+  init_task_runs();
+  init_task_commits();
+  init_database();
+  init_tasks();
+  init_sync_utils();
+  MANIFEST_FILES = ["package.json", "dashboard/package.json", "sdk/package.json"];
+  LOCKFILES = ["bun.lock", "bun.lockb", "package-lock.json", "npm-shrinkwrap.json"];
+  CONFIG_FILES = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "README.md",
+    "SECURITY.md",
+    "bunfig.toml",
+    "tsconfig.json",
+    "components.json",
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "vite.config.ts",
+    "dashboard/vite.config.ts"
+  ];
+});
+
 // src/mcp/index.ts
 init_agents();
 init_database();
@@ -14385,6 +14674,8 @@ var MCP_TOOL_GROUPS = {
     "check_file_lock",
     "create_comment",
     "create_handoff",
+    "capture_environment_snapshot",
+    "compare_environment_snapshots",
     "create_inbox_item",
     "delete_comment",
     "detect_file_relationships",
@@ -21853,19 +22144,55 @@ ${lines.join(`
   }
 }
 
+// src/mcp/tools/environment-snapshots.ts
+function registerEnvironmentSnapshotTools(server, { shouldRegisterTool, formatError }) {
+  if (shouldRegisterTool("capture_environment_snapshot")) {
+    server.tool("capture_environment_snapshot", "Capture a local reproducible environment snapshot with Bun/node versions, package-manager state, git status, config hashes, command metadata, and redacted manifests. Optionally attach it to a local task or run.", {
+      root: exports_external.string().optional(),
+      task_id: exports_external.string().optional(),
+      run_id: exports_external.string().optional(),
+      agent_id: exports_external.string().optional(),
+      command: exports_external.string().optional(),
+      output_path: exports_external.string().optional(),
+      include_env_values: exports_external.boolean().optional()
+    }, async (params) => {
+      try {
+        const { recordEnvironmentSnapshot: recordEnvironmentSnapshot2 } = await Promise.resolve().then(() => (init_environment_snapshots(), exports_environment_snapshots));
+        const result = recordEnvironmentSnapshot2(params);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("compare_environment_snapshots")) {
+    server.tool("compare_environment_snapshots", "Compare two local environment snapshot JSON files and report runtime, git, manifest, lockfile, and config hash drift.", {
+      left_path: exports_external.string(),
+      right_path: exports_external.string()
+    }, async ({ left_path, right_path }) => {
+      try {
+        const { compareEnvironmentSnapshotFiles: compareEnvironmentSnapshotFiles2 } = await Promise.resolve().then(() => (init_environment_snapshots(), exports_environment_snapshots));
+        return { content: [{ type: "text", text: JSON.stringify(compareEnvironmentSnapshotFiles2(left_path, right_path), null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+}
+
 // src/lib/package-version.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname7, join as join7 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname8, join as join8 } from "path";
 import { fileURLToPath } from "url";
 function getPackageVersion(fromUrl = import.meta.url) {
   try {
-    let dir = dirname7(fileURLToPath(fromUrl));
+    let dir = dirname8(fileURLToPath(fromUrl));
     for (let i = 0;i < 5; i++) {
-      const pkgPath = join7(dir, "package.json");
-      if (existsSync8(pkgPath)) {
-        return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
+      const pkgPath = join8(dir, "package.json");
+      if (existsSync9(pkgPath)) {
+        return JSON.parse(readFileSync7(pkgPath, "utf-8")).version || "0.0.0";
       }
-      const parent = dirname7(dir);
+      const parent = dirname8(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -22046,6 +22373,7 @@ registerTaskRelTools(server, toolContext);
 registerCodeTools(server, toolContext);
 registerAgentTools(server, { ...toolContext, agentFocusMap });
 registerTemplateTools(server, toolContext);
+registerEnvironmentSnapshotTools(server, toolContext);
 registerMachineTools(server, { shouldRegisterTool, formatError });
 registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError });
 async function main() {

package/dist/mcp/token-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token-utils.d.ts","sourceRoot":"","sources":["../../src/mcp/token-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAE3C,eAAO,MAAM,cAAc,aAoBzB,CAAC;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAqP7D,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAMhE,CAAC;AAgBF,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,YAAY,qBAA+B,EAC3C,UAAU,qBAAmC,GAC5C,OAAO,CAqCT;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,SAAM,GAAG,MAAM,GAAG,IAAI,CAK5F;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,mBAAmB,SAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgB1F;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqCtF;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAexD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAMD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,UAA4B,GAAG,OAAO,CA0BvH;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAY5D"}
+{"version":3,"file":"token-utils.d.ts","sourceRoot":"","sources":["../../src/mcp/token-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAE3C,eAAO,MAAM,cAAc,aAoBzB,CAAC;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAuP7D,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAMhE,CAAC;AAgBF,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,YAAY,qBAA+B,EAC3C,UAAU,qBAAmC,GAC5C,OAAO,CAqCT;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,SAAM,GAAG,MAAM,GAAG,IAAI,CAK5F;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,mBAAmB,SAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgB1F;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqCtF;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAexD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAMD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,UAA4B,GAAG,OAAO,CA0BvH;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAY5D"}

package/dist/mcp/tools/environment-snapshots.d.ts

@@ -0,0 +1,8 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+type Helpers = {
+    shouldRegisterTool: (name: string) => boolean;
+    formatError: (e: unknown) => string;
+};
+export declare function registerEnvironmentSnapshotTools(server: McpServer, { shouldRegisterTool, formatError }: Helpers): void;
+export {};
+//# sourceMappingURL=environment-snapshots.d.ts.map

package/dist/mcp/tools/environment-snapshots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment-snapshots.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/environment-snapshots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGzE,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;CACrC,CAAC;AAEF,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,kBAAkB,EAAE,WAAW,EAAE,EAAE,OAAO,GAAG,IAAI,CA4CtH"}

package/dist/mcp.js

@@ -189,6 +189,8 @@ var MCP_TOOL_GROUPS = {
     "check_file_lock",
     "create_comment",
     "create_handoff",
+    "capture_environment_snapshot",
+    "compare_environment_snapshots",
     "create_inbox_item",
     "delete_comment",
     "detect_file_relationships",

package/dist/registry.js

@@ -2433,6 +2433,50 @@ var TODOS_JSON_CONTRACTS = [
     },
     optional: {}
   }),
+  contract({
+    id: "environment_snapshot",
+    name: "Environment Snapshot",
+    description: "Local reproducibility snapshot for task and run verification context.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Snapshot schema version."),
+      id: field("string", "Content-derived snapshot identifier."),
+      captured_at: isoDateField,
+      root: field("string", "Canonical local project root inspected."),
+      machine: field("object", "Local hostname, platform, and architecture metadata."),
+      target: field("object", "Optional task, run, and agent attachment IDs."),
+      runtime: field("object", "Bun, Node, and executable metadata."),
+      package_manager: field("object", "Detected package manager, lockfile hashes, and redacted manifests."),
+      git: field("object", "Local git branch, commit, dirty state, and porcelain status."),
+      config_hashes: field("array", "SHA-256 hashes of relevant local config files."),
+      command_env: field("object", "Redacted command and environment metadata."),
+      warnings: field("array", "Warnings about missing or unavailable local data.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "environment_snapshot_comparison",
+    name: "Environment Snapshot Comparison",
+    description: "Drift summary returned when comparing two local environment snapshots.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Comparison schema version."),
+      left_id: field("string", "Left snapshot ID."),
+      right_id: field("string", "Right snapshot ID."),
+      same_root: field("boolean", "Whether both snapshots were captured for the same root."),
+      same_machine: field("boolean", "Whether hostname, platform, and architecture match."),
+      same_runtime: field("boolean", "Whether Bun and Node versions match."),
+      same_git_commit: field("boolean", "Whether git commit IDs match."),
+      dirty_state_changed: field("boolean", "Whether the git dirty flag changed."),
+      changed_config_hashes: field("array", "Changed config hash records."),
+      changed_lockfiles: field("array", "Changed lockfile hash records."),
+      changed_manifests: field("array", "Changed manifest hash records."),
+      warnings: field("array", "Comparison warnings.")
+    },
+    optional: {}
+  }),
   contract({
     id: "local_event_hook",
     name: "Local Event Hook",
@@ -7288,6 +7332,8 @@ var MCP_TOOL_GROUPS = {
     "check_file_lock",
     "create_comment",
     "create_handoff",
+    "capture_environment_snapshot",
+    "compare_environment_snapshots",
     "create_inbox_item",
     "delete_comment",
     "detect_file_relationships",
@@ -8262,6 +8308,18 @@ var TODOS_CLI_MCP_PARITY = [
       mcpTool: "build_agent_context_pack"
     }
   },
+  {
+    domain: "environment-snapshots",
+    cliCommands: ["todos env-snapshot"],
+    mcpTools: ["capture_environment_snapshot", "compare_environment_snapshots"],
+    jsonContracts: ["environment_snapshot", "environment_snapshot_comparison", "structured_error", "api_error"],
+    errorContracts: ["structured_error", "api_error"],
+    status: "matched",
+    example: {
+      cli: "todos env-snapshot capture --task 1234abcd --json",
+      mcpTool: "capture_environment_snapshot"
+    }
+  },
   {
     domain: "imports",
     cliCommands: [

package/dist/release-provenance.json

@@ -1,7 +1,7 @@
 {
   "packageName": "@hasna/todos",
-  "packageVersion": "0.11.43",
+  "packageVersion": "0.11.44",
   "repository": "https://github.com/hasna/todos.git",
-  "gitCommit": "3489eb9408277001cd3be9bb5c2996bb301e431d",
-  "generatedAt": "2026-05-21T17:17:52.886Z"
+  "gitCommit": "f6bc0dc0b71478ba56d4d044eb632f261ec623b4",
+  "generatedAt": "2026-05-21T17:49:00.069Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/todos",
-  "version": "0.11.43",
+  "version": "0.11.44",
   "description": "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   "type": "module",
   "main": "dist/index.js",