oreshnik-cli 0.1.0-alpha

package/dist/index.js

@@ -0,0 +1,3286 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/git.service.ts
+import { spawnSync } from "child_process";
+
+// src/types/index.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// src/core/git.service.ts
+var GitService = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  cwd;
+  exec(args) {
+    const result = spawnSync("git", args, { cwd: this.cwd, encoding: "utf8", timeout: 3e4 });
+    return {
+      ok: result.status === 0,
+      output: (result.stdout || "").trim(),
+      error: (result.stderr || "").trim(),
+      status: result.status ?? 1
+    };
+  }
+  fail(message, args, stderr) {
+    return {
+      code: "GIT_ERROR",
+      message,
+      exitCode: 1,
+      gitCommand: `git ${args.join(" ")}`,
+      gitStderr: stderr
+    };
+  }
+  // Read Operations
+  currentBranch() {
+    const r = this.exec(["branch", "--show-current"]);
+    if (!r.ok) return err(this.fail("Failed to get current branch", ["branch", "--show-current"], r.error));
+    return ok(r.output || "DETACHED");
+  }
+  refExists(ref) {
+    return this.exec(["rev-parse", "--verify", ref]).ok;
+  }
+  resolveRef(ref) {
+    const r = this.exec(["rev-parse", "--verify", ref]);
+    if (!r.ok) return err(this.fail(`Ref not found: ${ref}`, ["rev-parse", "--verify", ref], r.error));
+    return ok(r.output);
+  }
+  statusPorcelain() {
+    const r = this.exec(["status", "--porcelain"]);
+    if (!r.ok) return err(this.fail("Failed to get working tree status", ["status", "--porcelain"], r.error));
+    const lines = r.output.split(/\r?\n/).filter(Boolean);
+    const entries = lines.map((line) => ({
+      status: line.slice(0, 2).trim(),
+      path: line.slice(3).replace(/^.* -> /, "")
+    }));
+    return ok(entries);
+  }
+  fetch(remote = "origin") {
+    const r = this.exec(["fetch", remote, "--prune", "--quiet"]);
+    if (!r.ok) return err(this.fail(`Failed to fetch from ${remote}`, ["fetch", remote, "--prune"], r.error));
+    return ok(void 0);
+  }
+  getMergeBase(a, b) {
+    const r = this.exec(["merge-base", a, b]);
+    if (!r.ok) return err(this.fail(`No merge base between ${a} and ${b}`, ["merge-base", a, b], r.error));
+    return ok(r.output);
+  }
+  discoverLatestMother(prefix = "MADRE") {
+    const r = this.exec([
+      "for-each-ref",
+      "--format=%(refname:short)",
+      `refs/heads/${prefix}`,
+      `refs/remotes/origin/${prefix}`
+    ]);
+    if (!r.ok) {
+      return err(this.fail(`Failed to discover latest ${prefix} branch`, [
+        "for-each-ref",
+        "--format=%(refname:short)",
+        `refs/heads/${prefix}`,
+        `refs/remotes/origin/${prefix}`
+      ], r.error));
+    }
+    const refs = r.output.split(/\r?\n/).filter(Boolean).map((ref) => ({
+      name: ref.replace(/^origin\//, ""),
+      remote: ref.startsWith("origin/")
+    }));
+    const latest = refs.map((ref) => {
+      const v = Number(ref.name.match(new RegExp(`^${prefix}/v(\\d+)`, "i"))?.[1] || 0);
+      return { ...ref, version: v };
+    }).filter((item) => item.version > 0).sort((a, b) => b.version - a.version || a.name.localeCompare(b.name))[0] || null;
+    if (!latest) return ok(null);
+    return ok({ name: latest.name, version: latest.version, remote: latest.remote });
+  }
+  diffNames(base, target, paths) {
+    const args = ["diff", "--name-only", `${base}...${target}`];
+    if (paths) args.push("--", ...paths);
+    const r = this.exec(args);
+    if (!r.ok) return err(this.fail(`Failed to diff ${base}...${target}`, args, r.error));
+    return ok(r.output.split(/\r?\n/).filter(Boolean));
+  }
+  unmergedFiles() {
+    const args = ["diff", "--name-only", "--diff-filter=U"];
+    const r = this.exec(args);
+    if (!r.ok) return err(this.fail("Failed to inspect unmerged files", args, r.error));
+    return ok(r.output.split(/\r?\n/).filter(Boolean));
+  }
+  showRef(ref, file) {
+    const r = this.exec(["show", `${ref}:${file}`]);
+    if (!r.ok) return ok(null);
+    return ok(r.output);
+  }
+  // Write Operations
+  createBranch(name, from) {
+    const args = ["checkout", "-b", name];
+    if (from) args.push(from);
+    const r = this.exec(args);
+    if (!r.ok) return err(this.fail(`Failed to create branch ${name}`, args, r.error));
+    return ok(void 0);
+  }
+  checkout(branch) {
+    const r = this.exec(["checkout", branch]);
+    if (!r.ok) return err(this.fail(`Failed to checkout ${branch}`, ["checkout", branch], r.error));
+    return ok(void 0);
+  }
+  merge(ref, options) {
+    const args = ["merge"];
+    if (options?.noCommit) args.push("--no-commit");
+    if (options?.noFF) args.push("--no-ff");
+    if (options?.strategy) args.push("--strategy", options.strategy);
+    if (options?.message) args.push("-m", options.message);
+    args.push(ref);
+    const r = this.exec(args);
+    if (!r.ok) return err(this.fail(`Failed to merge ${ref}`, args, r.error));
+    return ok(void 0);
+  }
+  push(remote, branch, force = false) {
+    const args = ["push", remote, branch];
+    if (force) args.push("--force");
+    const r = this.exec(args);
+    if (!r.ok) return err(this.fail(`Failed to push ${branch} to ${remote}`, args, r.error));
+    return ok(void 0);
+  }
+  pushTag(remote, tag) {
+    const args = ["push", remote, tag];
+    const r = this.exec(args);
+    if (!r.ok) return err(this.fail(`Failed to push tag ${tag} to ${remote}`, args, r.error));
+    return ok(void 0);
+  }
+  stage(files) {
+    const r = this.exec(["add", "--", ...files]);
+    if (!r.ok) return err(this.fail("Failed to stage files", ["add", ...files], r.error));
+    return ok(void 0);
+  }
+  commit(message) {
+    const r = this.exec(["commit", "-m", message]);
+    if (!r.ok) return err(this.fail("Failed to commit", ["commit", "-m", message], r.error));
+    return ok(void 0);
+  }
+  createTag(name, message) {
+    const r = this.exec(["tag", "-a", name, "-m", message]);
+    if (!r.ok) return err(this.fail(`Failed to create tag ${name}`, ["tag", "-a", name, "-m", message], r.error));
+    return ok(void 0);
+  }
+  deleteTag(name) {
+    const r = this.exec(["tag", "-d", name]);
+    if (!r.ok) return err(this.fail(`Failed to delete tag ${name}`, ["tag", "-d", name], r.error));
+    return ok(void 0);
+  }
+  // Destructive Operations
+  resetHard(ref) {
+    const r = this.exec(["reset", "--hard", ref]);
+    if (!r.ok) return err(this.fail(`Failed to reset to ${ref}`, ["reset", "--hard", ref], r.error));
+    return ok(void 0);
+  }
+  deleteBranch(branch, force = false) {
+    const args = ["branch", "-d", branch];
+    if (force) args.splice(1, 0, "-D");
+    const r = this.exec(args);
+    if (!r.ok) return err(this.fail(`Failed to delete branch ${branch}`, args, r.error));
+    return ok(void 0);
+  }
+  stashPush(message) {
+    const args = ["stash", "push"];
+    if (message) args.push("-m", message);
+    const r = this.exec(args);
+    if (!r.ok) return err(this.fail("Failed to stash", args, r.error));
+    return ok(r.output || null);
+  }
+  stashPop() {
+    const r = this.exec(["stash", "pop"]);
+    if (!r.ok) return err(this.fail("Failed to pop stash", ["stash", "pop"], r.error));
+    return ok(void 0);
+  }
+  // Lock Operations (remote git locks)
+  pushLockRef(zone, _lockContent) {
+    return err(this.fail(`Remote lock acquisition is not implemented for ${zone}`, ["push", "origin", `refs/oreshnik/locks/${zone}`]));
+  }
+  deleteLockRef(zone) {
+    return err(this.fail(`Remote lock release is not implemented for ${zone}`, ["push", "origin", "--delete", `refs/oreshnik/locks/${zone}`]));
+  }
+  fetchLockRefs() {
+    return err(this.fail("Remote lock listing is not implemented", ["for-each-ref", "refs/remotes/origin/oreshnik/locks/"]));
+  }
+  getLockContent(ref) {
+    return err(this.fail(`Remote lock content is not implemented for ${ref}`, ["show", ref]));
+  }
+  // Cherry-pick (for sync)
+  cherryPick(commit) {
+    const r = this.exec(["cherry-pick", commit]);
+    if (!r.ok) return err(this.fail(`Failed to cherry-pick ${commit}`, ["cherry-pick", commit], r.error));
+    return ok(void 0);
+  }
+  restoreFromHead(pattern) {
+    const r = this.exec(["checkout", "HEAD", "--", pattern]);
+    if (!r.ok) return err(this.fail(`Failed to restore ${pattern} from HEAD`, ["checkout", "HEAD", "--", pattern], r.error));
+    return ok(void 0);
+  }
+  // Utility
+  userConfig(key) {
+    const r = this.exec(["config", key]);
+    if (!r.ok) return err(this.fail(`Git config ${key} not set`, ["config", key]));
+    return ok(r.output);
+  }
+  mergeFileUnion(currentFile, baseFile, sourceFile) {
+    const r = spawnSync("git", ["merge-file", "--union", "-p", currentFile, baseFile, sourceFile], {
+      cwd: this.cwd,
+      encoding: "utf8",
+      timeout: 1e4
+    });
+    if (r.status !== 0) {
+      return err(this.fail("Failed to merge file with union strategy", ["merge-file", "--union", "-p", currentFile, baseFile, sourceFile], r.stderr || ""));
+    }
+    return ok((r.stdout || "").trim());
+  }
+};
+function createGitService(cwd) {
+  return new GitService(cwd);
+}
+
+// src/core/zone-engine.ts
+var ZoneEngine = class {
+  globToRegex(glob) {
+    const doubleStarToken = "__DOUBLE_STAR__";
+    const escaped = glob.replaceAll("**", doubleStarToken).replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*").replaceAll(doubleStarToken, ".*");
+    return new RegExp(`^${escaped}$`);
+  }
+  findMatchingZone(file, zoneMap) {
+    for (const [pattern, zone] of Object.entries(zoneMap.zones)) {
+      if (this.globToRegex(pattern).test(file)) {
+        return { pattern, zone };
+      }
+    }
+    return null;
+  }
+  check(files, operator, sprint, zoneMap) {
+    const violations = [];
+    const warnings = [];
+    for (const file of files) {
+      const match = this.findMatchingZone(file, zoneMap);
+      if (!match) {
+        warnings.push({ file, reason: `no-zone-entry: ${file} not mapped in zone-map.json` });
+        continue;
+      }
+      const { pattern, zone } = match;
+      const allowed = zone.sprints.includes("*") || zone.sprints.includes(sprint);
+      if (!allowed) {
+        warnings.push({ file, reason: `sprint-not-allowed: ${pattern} not mapped to sprint ${sprint}` });
+      }
+      const result = this.checkLock(file, pattern, zone.lock, zone.owner, operator);
+      if (result.violation) violations.push(result.violation);
+      if (result.warning) warnings.push(result.warning);
+    }
+    return { violations, warnings, filesChecked: files.length };
+  }
+  checkLock(file, zonePattern, lock, zoneOwner, operator) {
+    switch (lock) {
+      case "forbidden":
+        return {
+          violation: { file, zone: zonePattern, reason: "forbidden-zone: no operator may modify this zone" }
+        };
+      case "operator_exclusive":
+        if (zoneOwner !== operator) {
+          return {
+            violation: { file, zone: zonePattern, reason: `exclusive-zone: owned by ${zoneOwner}, operator is ${operator}` }
+          };
+        }
+        break;
+      case "operator_double":
+        return {
+          warning: { file, reason: `double-lock-required: ${zonePattern} needs coordination with ${zoneOwner}` }
+        };
+      case "shared":
+        break;
+      case "owner_per_sprint":
+        break;
+    }
+    return {};
+  }
+  getModifiedZones(files, zoneMap) {
+    const zones = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      const match = this.findMatchingZone(file, zoneMap);
+      if (match) zones.add(match.pattern);
+    }
+    return zones;
+  }
+};
+function createZoneEngine() {
+  return new ZoneEngine();
+}
+
+// src/core/state-manager.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { randomBytes } from "crypto";
+var StateManager = class {
+  constructor(root) {
+    this.root = root;
+    this.runsDir = join(root, "var", "oreshnik");
+    mkdirSync(this.runsDir, { recursive: true });
+  }
+  root;
+  runsDir;
+  // ─── File Operations ───────────────────────────────────────
+  readJson(filePath) {
+    try {
+      if (!existsSync(filePath)) {
+        return err({ code: "STATE_ERROR", message: `File not found: ${filePath}`, exitCode: 1 });
+      }
+      const content = readFileSync(filePath, "utf8").replace(/^\uFEFF/, "");
+      return ok(JSON.parse(content));
+    } catch (e) {
+      return err({
+        code: "STATE_ERROR",
+        message: `Failed to read/parse ${filePath}: ${String(e)}`,
+        exitCode: 1
+      });
+    }
+  }
+  writeJson(filePath, value) {
+    try {
+      mkdirSync(join(filePath, ".."), { recursive: true });
+      writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+      return ok(void 0);
+    } catch (e) {
+      return err({
+        code: "STATE_ERROR",
+        message: `Failed to write ${filePath}: ${String(e)}`,
+        exitCode: 1
+      });
+    }
+  }
+  readText(filePath) {
+    try {
+      if (!existsSync(filePath)) return ok("");
+      return ok(readFileSync(filePath, "utf8"));
+    } catch (e) {
+      return err({
+        code: "STATE_ERROR",
+        message: `Failed to read ${filePath}: ${String(e)}`,
+        exitCode: 1
+      });
+    }
+  }
+  writeText(filePath, content) {
+    try {
+      mkdirSync(join(filePath, ".."), { recursive: true });
+      writeFileSync(filePath, content, "utf8");
+      return ok(void 0);
+    } catch (e) {
+      return err({
+        code: "STATE_ERROR",
+        message: `Failed to write ${filePath}: ${String(e)}`,
+        exitCode: 1
+      });
+    }
+  }
+  // ─── Merge Helpers ─────────────────────────────────────────
+  mergeTextUnion(file, base, current, source) {
+    const tmpDir = join(this.runsDir, ".merge-tmp");
+    mkdirSync(tmpDir, { recursive: true });
+    const id = randomBytes(8).toString("hex");
+    const basePath = join(tmpDir, `base-${id}`);
+    const curPath = join(tmpDir, `current-${id}`);
+    const srcPath = join(tmpDir, `source-${id}`);
+    try {
+      writeFileSync(basePath, base, "utf8");
+      writeFileSync(curPath, current, "utf8");
+      writeFileSync(srcPath, source, "utf8");
+      const result = spawnSync2("git", ["merge-file", "--union", "-p", curPath, basePath, srcPath], {
+        cwd: this.root,
+        encoding: "utf8",
+        timeout: 1e4
+      });
+      return ok(result.stdout || "");
+    } catch (e) {
+      return err({
+        code: "STATE_ERROR",
+        message: `Merge failed for ${file}: ${String(e)}`,
+        exitCode: 1
+      });
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  }
+  mergeJsonSmart(base, current, source) {
+    try {
+      const merged = this.mergeValue(base, current, source);
+      return ok(merged);
+    } catch (e) {
+      return err({
+        code: "STATE_ERROR",
+        message: `JSON merge failed: ${String(e)}`,
+        exitCode: 1
+      });
+    }
+  }
+  mergeValue(base, current, source) {
+    const key = (v) => JSON.stringify(v);
+    if (key(current) === key(source)) return current;
+    if (key(current) === key(base)) return source;
+    if (key(source) === key(base)) return current;
+    if (current && source && typeof current === "object" && typeof source === "object" && !Array.isArray(current) && !Array.isArray(source)) {
+      const result = { ...current };
+      const allKeys = /* @__PURE__ */ new Set([
+        ...Object.keys(base || {}),
+        ...Object.keys(current),
+        ...Object.keys(source)
+      ]);
+      for (const k of allKeys) {
+        result[k] = this.mergeValue(
+          base?.[k],
+          current[k],
+          source[k]
+        );
+      }
+      return result;
+    }
+    if (Array.isArray(current) && Array.isArray(source)) {
+      const seen = /* @__PURE__ */ new Set();
+      const merged = [...current, ...source].filter((item) => {
+        const k = key(item);
+        if (seen.has(k)) return false;
+        seen.add(k);
+        return true;
+      });
+      return merged;
+    }
+    return source;
+  }
+  // ─── Lock Management ───────────────────────────────────────
+  acquireLocalLock(lockName, timeoutMs = 5e3) {
+    const lockPath = join(this.runsDir, `.lock-${lockName}`);
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      try {
+        const fd = this.openExclusive(lockPath);
+        if (fd !== null) {
+          return ok({ path: lockPath, fd });
+        }
+      } catch {
+      }
+      const waited = Date.now() - start;
+      if (waited < timeoutMs) {
+        const waitUntil = Date.now() + 50;
+        while (Date.now() < waitUntil) {
+        }
+      }
+    }
+    return err({
+      code: "STATE_ERROR",
+      message: `Could not acquire lock ${lockName} within ${timeoutMs}ms`,
+      exitCode: 1
+    });
+  }
+  openExclusive(path) {
+    try {
+      const fs = __require("fs");
+      const fd = fs.openSync(path, "wx");
+      return fd;
+    } catch {
+      return null;
+    }
+  }
+  releaseLocalLock(handle) {
+    try {
+      const fs = __require("fs");
+      fs.closeSync(handle.fd);
+      fs.unlinkSync(handle.path);
+      return ok(void 0);
+    } catch (e) {
+      return err({
+        code: "STATE_ERROR",
+        message: `Failed to release lock: ${String(e)}`,
+        exitCode: 1
+      });
+    }
+  }
+};
+function createStateManager(root) {
+  return new StateManager(root);
+}
+
+// src/core/canonical.service.ts
+import { join as join2 } from "path";
+var CanonicalService = class {
+  constructor(state, root) {
+    this.state = state;
+    this.root = root;
+  }
+  state;
+  root;
+  checkCanonicalAlignment(taskBoard, derivedDocs, mother, relicTaskIds = [], assignmentTaskIds = []) {
+    const issues = [];
+    const tasks = taskBoard.tasks;
+    const taskById = new Map(tasks.map((t) => [t.id, t]));
+    const openTasks = tasks.filter((t) => t.status !== "done");
+    const statusBoardDoc = derivedDocs.find((d) => d.type === "status-board");
+    for (const doc of derivedDocs) {
+      const fullPath = join2(this.root, doc.path);
+      const content = this.state.readText(fullPath);
+      if (!content.ok || !content.value) {
+        issues.push({
+          file: doc.path,
+          severity: "blocker",
+          reason: `${doc.path} is missing or empty.`
+        });
+        continue;
+      }
+      const text = content.value;
+      for (const taskId of relicTaskIds) {
+        if (this.hasLegacyClosureConflict(text, taskId, taskById)) {
+          issues.push({
+            file: doc.path,
+            severity: "blocker",
+            reason: `${doc.path} still reports stale ${taskId} no-closure state, but task-board marks it done.`
+          });
+        }
+      }
+      for (const taskId of assignmentTaskIds) {
+        if (this.hasAssignmentConflict(text, taskId, taskById)) {
+          const task = taskById.get(taskId);
+          issues.push({
+            file: doc.path,
+            severity: "blocker",
+            reason: `${doc.path} assigns ${taskId} away from canonical owner ${task?.owner}.`
+          });
+        }
+      }
+    }
+    if (statusBoardDoc) {
+      const statusPath = join2(this.root, statusBoardDoc.path);
+      const statusText = this.state.readText(statusPath);
+      if (statusText.ok && statusText.value) {
+        for (const task of openTasks) {
+          if (!statusText.value.includes(task.id)) {
+            issues.push({
+              file: statusBoardDoc.path,
+              severity: "warn",
+              reason: `Status board does not include open task ${task.id}: ${task.title}.`
+            });
+          }
+        }
+      }
+    }
+    return {
+      aligned: issues.filter((i) => i.severity === "blocker").length === 0,
+      issues,
+      boardUpdatedAt: taskBoard.updatedAt
+    };
+  }
+  regenerateAllDerivedDocs(taskBoard, derivedDocs, mother, projectName) {
+    for (const doc of derivedDocs) {
+      let content;
+      if (doc.type === "central") {
+        content = this.generateCentral(taskBoard, mother, projectName, doc.extra);
+      } else if (doc.type === "collaborator" && doc.filter?.owner) {
+        content = this.generateCollaborator(taskBoard, doc.filter.owner, projectName);
+      } else if (doc.type === "status-board") {
+        content = this.generateStatusBoard(taskBoard, projectName);
+      } else {
+        continue;
+      }
+      const fullPath = join2(this.root, doc.path);
+      const writeResult = this.state.writeText(fullPath, content);
+      if (!writeResult.ok) return writeResult;
+    }
+    return ok(void 0);
+  }
+  generateCentral(taskBoard, mother, projectName, extra) {
+    const openTasks = taskBoard.tasks.filter((t) => t.status !== "done");
+    const readyTasks = openTasks.filter((t) => t.status === "ready");
+    const pendingTasks = openTasks.filter((t) => t.status === "pending");
+    const taskRows = (list) => list.length === 0 ? "| Ninguno | - | - | - |\n" : list.map((t) => `| ${t.id} | ${t.status} | ${t.owner} | ${t.title} | ${t.dependsOn?.join(", ") || "-"} |`).join("\n");
+    const extraFields = extra ? Object.entries(extra).map(([k, v]) => `| ${k} | ${v} |`).join("\n") : "";
+    return [
+      "---",
+      `type: master-dashboard`,
+      `project: "${projectName}"`,
+      `status: active-production`,
+      `phase: "Canonical Oreshnik task board governs current assignments"`,
+      `last_updated: "${this.nowISO()}"`,
+      `mother_branch: "${mother.current || "unknown"}"`,
+      "tags:",
+      '  - "#central"',
+      '  - "#status/live-source"',
+      "---",
+      "",
+      `# ${projectName} - Dashboard Canonico`,
+      "",
+      "> Fuente operativa: `var/oreshnik/task-board.json`. Los documentos de colaborador y status son derivados y deben ser regenerados si cambian las asignaciones.",
+      "",
+      "## Estado Actual",
+      "",
+      "| Campo | Valor |",
+      "|---|---|",
+      `| Task board actualizado | ${taskBoard.updatedAt || "unknown"} |`,
+      `| Rama madre | ${mother.current || "unknown"} |`,
+      extraFields,
+      "",
+      "## Orden de Ejecucion",
+      "",
+      ...taskBoard.currentExecutionOrder.map((item) => `- ${item}`),
+      "",
+      "## Tareas Abiertas",
+      "",
+      "| Sprint | Estado | Owner | Scope | Depende de |",
+      "|---|---|---|---|---|",
+      taskRows(openTasks),
+      "",
+      "## Ready Ahora",
+      "",
+      "| Sprint | Owner | Scope |",
+      "|---|---|---|",
+      readyTasks.length ? readyTasks.map((t) => `| ${t.id} | ${t.owner} | ${t.title} |`).join("\n") : "| Ninguno | - | - |",
+      "",
+      "## Pendientes Bloqueados por Dependencias",
+      "",
+      "| Sprint | Owner | Scope | Depende de |",
+      "|---|---|---|---|",
+      pendingTasks.length ? pendingTasks.map((t) => `| ${t.id} | ${t.owner} | ${t.title} | ${t.dependsOn?.join(", ") || "-"} |`).join("\n") : "| Ninguno | - | - | - |",
+      ""
+    ].join("\n");
+  }
+  generateCollaborator(taskBoard, owner, projectName) {
+    const assigned = taskBoard.tasks.filter(
+      (t) => t.status !== "done" && (t.owner === owner || String(t.owner).includes(`${owner}+`) || String(t.owner).includes(`+${owner}`))
+    );
+    const ready = assigned.filter((t) => t.status === "ready");
+    const pending = assigned.filter((t) => t.status === "pending");
+    const acceptanceRows = (task) => (task.acceptance || []).map((item) => `- ${item}`).join("\n");
+    const taskRows = (list) => list.length === 0 ? "| Ninguno | - | - |" : list.map((t) => `| ${t.id} | ${t.title} | ${t.dependsOn?.join(", ") || "-"} |`).join("\n");
+    return [
+      "---",
+      `type: collaborator-status`,
+      `project: "${projectName}"`,
+      `operator: "${owner}"`,
+      `last_updated: "${this.nowISO()}"`,
+      `generated_by: "Oreshnik canonical-check"`,
+      `source: "var/oreshnik/task-board.json"`,
+      "---",
+      "",
+      `# Estado ${owner}`,
+      "",
+      "> Documento derivado. La fuente operativa es `var/oreshnik/task-board.json`.",
+      "",
+      "## Ready",
+      "",
+      "| Sprint | Scope | Depende de |",
+      "|---|---|---|",
+      taskRows(ready),
+      "",
+      "## Pending",
+      "",
+      "| Sprint | Scope | Depende de |",
+      "|---|---|---|",
+      taskRows(pending),
+      "",
+      "## Detalle de Aceptacion",
+      "",
+      assigned.length ? assigned.map(
+        (t) => `### ${t.id} - ${t.title}
+
+Estado: \`${t.status}\`
+
+${acceptanceRows(t)}
+
+Zonas: ${(t.zone || []).map((z2) => `\`${z2}\``).join(", ") || "-"}
+`
+      ).join("\n") : "Sin tareas abiertas asignadas.",
+      ""
+    ].join("\n");
+  }
+  generateStatusBoard(taskBoard, projectName) {
+    const openTasks = taskBoard.tasks.filter((t) => t.status !== "done");
+    const doneTasks = taskBoard.tasks.filter((t) => t.status === "done");
+    const ownerRows = (owner) => {
+      const owned = openTasks.filter((t) => t.owner === owner || String(t.owner).includes(`${owner}+`) || String(t.owner).includes(`+${owner}`));
+      return owned.length ? owned.map((t) => `| ${t.id} | ${t.status} | ${t.title} | ${t.dependsOn?.join(", ") || "-"} |`).join("\n") : "| Ninguno | - | - | - |";
+    };
+    return [
+      "---",
+      `type: status-board`,
+      `project: "${projectName}"`,
+      `last_updated: "${this.nowISO()}"`,
+      `generated_by: "Oreshnik canonical-check"`,
+      `source: "var/oreshnik/task-board.json"`,
+      "---",
+      "",
+      "# STATUS BOARD - Realidad Canonica del Repositorio",
+      "",
+      "> Fuente operativa: `var/oreshnik/task-board.json`. Si este documento contradice el task board, el preflight debe bloquear.",
+      "",
+      "## Orden de Ejecucion Actual",
+      "",
+      ...taskBoard.currentExecutionOrder.map((item) => `- ${item}`),
+      "",
+      "## Tareas Ready/Pending",
+      "",
+      "| Sprint | Estado | Owner | Scope | Depende de |",
+      "|---|---|---|---|---|",
+      openTasks.map((t) => `| ${t.id} | ${t.status} | ${t.owner} | ${t.title} | ${t.dependsOn?.join(", ") || "-"} |`).join("\n"),
+      "",
+      "## Hard Stops Vigentes",
+      "",
+      "- No credenciales en git.",
+      "- No sprint closure sin vault, handoff y validaciones.",
+      "",
+      "## Sprints Cerrados Segun Task Board",
+      "",
+      "| Sprint | Owner | Scope |",
+      "|---|---|---|",
+      doneTasks.map((t) => `| ${t.id} | ${t.owner} | ${t.title} |`).join("\n"),
+      ""
+    ].join("\n");
+  }
+  hasLegacyClosureConflict(content, taskId, taskById) {
+    const task = taskById.get(taskId);
+    if (task?.status !== "done") return false;
+    const pattern = new RegExp(
+      `${taskId}[\\s\\S]{0,700}(SIN CLOSURE|sin closure|NO EXISTE|CERO commits|sin codigo visible|no code visible)`,
+      "i"
+    );
+    return pattern.test(content);
+  }
+  hasAssignmentConflict(content, taskId, taskById) {
+    const task = taskById.get(taskId);
+    if (!task || task.status === "done") return false;
+    return false;
+  }
+  nowISO() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+function createCanonicalService(state, root) {
+  return new CanonicalService(state, root);
+}
+
+// src/core/sync.service.ts
+import { join as join3 } from "path";
+var SyncService = class {
+  constructor(git, state, canonical, root) {
+    this.git = git;
+    this.state = state;
+    this.canonical = canonical;
+    this.root = root;
+  }
+  git;
+  state;
+  canonical;
+  root;
+  syncLatestMother(args) {
+    const result = {
+      success: false,
+      merged: false,
+      latestMother: "",
+      conflicts: [],
+      autoResolved: [],
+      manualRequired: []
+    };
+    const taskBoardRel = "var/oreshnik/task-board.json";
+    const derivedDocPaths = args.derivedDocPaths.map((p) => this.toGitPath(p));
+    const autoConflicts = /* @__PURE__ */ new Set([
+      ...(args.canonicalAutoConflicts || []).map((p) => this.toGitPath(p)),
+      ...derivedDocPaths,
+      taskBoardRel
+    ]);
+    const fetchResult = this.git.fetch();
+    if (!fetchResult.ok) {
+      result.conflicts.push(`Fetch failed: ${fetchResult.error.message}`);
+      return result;
+    }
+    const motherResult = this.readMother();
+    if (!motherResult.ok) return result;
+    const currentMother = motherResult.value;
+    const latest = this.git.discoverLatestMother(args.motherPrefix);
+    if (!latest.ok || !latest.value) {
+      result.success = true;
+      result.latestMother = currentMother.current;
+      return result;
+    }
+    const latestRef = this.git.refExists(`origin/${latest.value.name}`) ? `origin/${latest.value.name}` : latest.value.name;
+    result.latestMother = latest.value.name;
+    if (latest.value.version <= (currentMother.version || 0)) {
+      result.success = true;
+      result.latestMother = currentMother.current;
+      return result;
+    }
+    const dirty = this.git.statusPorcelain();
+    if (!dirty.ok) {
+      result.conflicts.push(`Failed to inspect working tree: ${dirty.error.message}`);
+      return result;
+    }
+    const dirtyFiles = dirty.value.filter((e) => !this.toGitPath(e.path).startsWith("var/oreshnik/") && !this.toGitPath(e.path).startsWith("output/")).map((e) => this.toGitPath(e.path));
+    if (dirtyFiles.length > 0) {
+      result.conflicts.push(`Working tree has ${dirtyFiles.length} changed file(s).`);
+      return result;
+    }
+    const merge = this.git.merge(latestRef, {
+      noFF: true,
+      message: `chore(oreshnik): sync from ${latest.value.name}`
+    });
+    if (merge.ok) {
+      result.success = true;
+      result.merged = true;
+      return result;
+    }
+    const conflictFiles = this.git.unmergedFiles();
+    if (!conflictFiles.ok) {
+      result.conflicts.push(`Failed to inspect merge conflicts: ${conflictFiles.error.message}`);
+      return result;
+    }
+    const conflicts = conflictFiles.value.map((p) => this.toGitPath(p));
+    const manual = conflicts.filter((f) => !autoConflicts.has(f));
+    if (manual.length > 0) {
+      result.manualRequired = manual;
+      return result;
+    }
+    const taskBoardPath = taskBoardRel;
+    if (conflicts.includes(taskBoardRel)) {
+      const mergeResult = this.mergeTaskBoardById(taskBoardPath);
+      if (!mergeResult.ok) {
+        result.conflicts.push(mergeResult.error.message);
+        return result;
+      }
+      result.autoResolved.push(taskBoardRel);
+    }
+    const motherVersion = this.readMother();
+    const mother = motherVersion.ok ? motherVersion.value : { version: 0, current: "unknown", branches: [] };
+    const boardData = this.state.readJson(taskBoardPath);
+    const board = boardData.ok ? boardData.value : { project: args.projectName, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), currentExecutionOrder: [], tasks: [] };
+    const regenResult = this.canonical.regenerateAllDerivedDocs(
+      board,
+      args.derivedDocs.map((d) => ({ ...d, source: "task-board" })),
+      mother,
+      args.projectName
+    );
+    if (!regenResult.ok) {
+      result.conflicts.push(`Derived doc regeneration failed: ${regenResult.error.message}`);
+      return result;
+    }
+    const stageFiles = [taskBoardRel, ...derivedDocPaths];
+    const stageResult = this.git.stage(stageFiles);
+    if (!stageResult.ok) {
+      result.conflicts.push(`Failed to stage auto-resolved files: ${stageResult.error.message}`);
+      return result;
+    }
+    result.autoResolved.push(...derivedDocPaths);
+    const remaining = this.git.unmergedFiles();
+    if (!remaining.ok) {
+      result.conflicts.push(`Failed to inspect remaining merge conflicts: ${remaining.error.message}`);
+      return result;
+    }
+    if (remaining.value.length > 0) {
+      result.manualRequired = remaining.value.map((p) => this.toGitPath(p));
+      return result;
+    }
+    const commitResult = this.git.commit("chore(oreshnik): auto-resolve canonical conflicts");
+    if (!commitResult.ok) {
+      result.conflicts.push(`Failed to commit auto-resolved conflicts: ${commitResult.error.message}`);
+      return result;
+    }
+    result.success = true;
+    result.merged = true;
+    return result;
+  }
+  mergeTaskBoardById(fileRel) {
+    const fullPath = join3(this.root, ...fileRel.split("/"));
+    const oursRaw = this.git.showRef(":2", fileRel);
+    const theirsRaw = this.git.showRef(":3", fileRel);
+    if (!oursRaw.ok && !theirsRaw.ok) {
+      return err({ code: "STATE_ERROR", message: `Cannot read conflict stages for ${fileRel}`, exitCode: 1 });
+    }
+    try {
+      const ours = oursRaw.ok && oursRaw.value ? JSON.parse(oursRaw.value.replace(/^\uFEFF/, "")) : { project: "", updatedAt: "", currentExecutionOrder: [], tasks: [] };
+      const theirs = theirsRaw.ok && theirsRaw.value ? JSON.parse(theirsRaw.value.replace(/^\uFEFF/, "")) : { project: "", updatedAt: "", currentExecutionOrder: [], tasks: [] };
+      const merged = {
+        project: theirs.project || ours.project,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        currentExecutionOrder: theirs.currentExecutionOrder || ours.currentExecutionOrder,
+        tasks: structuredClone(theirs.tasks),
+        reassignments: this.mergeUniqueReassignments(ours.reassignments || [], theirs.reassignments || [])
+      };
+      const mergedIds = new Set(merged.tasks.map((t) => t.id));
+      const oursOnly = [];
+      for (const task of ours.tasks || []) {
+        if (!mergedIds.has(task.id)) {
+          const releaseIdx = merged.tasks.findIndex((t) => t.id.includes("RELEASE"));
+          if (releaseIdx >= 0) merged.tasks.splice(releaseIdx, 0, task);
+          else merged.tasks.push(task);
+          mergedIds.add(task.id);
+          oursOnly.push(task.id);
+        }
+      }
+      const theirsOnly = (theirs.tasks || []).filter((t) => !new Set((ours.tasks || []).map((o) => o.id)).has(t.id)).map((t) => t.id);
+      const writeResult = this.state.writeJson(fullPath, merged);
+      if (!writeResult.ok) return writeResult;
+      return ok({ merged, oursOnly, theirsOnly });
+    } catch (e) {
+      return err({ code: "STATE_ERROR", message: `Failed to merge task board: ${String(e)}`, exitCode: 1 });
+    }
+  }
+  mergeUniqueReassignments(a, b) {
+    const seen = /* @__PURE__ */ new Set();
+    return [...a, ...b].filter((item) => {
+      const key = JSON.stringify(item);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+  readMother() {
+    const path = join3(this.root, "var", "oreshnik", ".mother-version.json");
+    return this.state.readJson(path);
+  }
+  runsDir(file) {
+    return `var/oreshnik/${file}`;
+  }
+  toGitPath(path) {
+    return path.replace(/\\/g, "/");
+  }
+};
+function createSyncService(git, state, canonical, root) {
+  return new SyncService(git, state, canonical, root);
+}
+
+// src/core/vault-guard.ts
+var VaultGuard = class {
+  constructor(git) {
+    this.git = git;
+  }
+  git;
+  check(vaultPath, obsidianConfigDir, force = false) {
+    const result = {
+      clean: true,
+      configDirty: [],
+      configRestored: false,
+      contentDirty: [],
+      unstagedStagedOverlap: [],
+      untracked: [],
+      errors: []
+    };
+    const configDirty = this.gitDirtyFiles(`${obsidianConfigDir}/`, vaultPath);
+    if (!configDirty.ok) {
+      result.clean = false;
+      result.errors.push(configDirty.error.message);
+    } else if (configDirty.value.length > 0) {
+      result.configDirty = configDirty.value;
+      if (force) {
+        const restore = this.git.restoreFromHead(`${obsidianConfigDir}/`);
+        if (restore.ok) {
+          result.configRestored = true;
+        } else {
+          result.clean = false;
+        }
+      } else {
+        result.clean = false;
+      }
+    }
+    const vaultDirty = this.gitDirtyFiles(`${vaultPath}/`, vaultPath, `:!${obsidianConfigDir}`);
+    if (!vaultDirty.ok) {
+      result.clean = false;
+      result.errors.push(vaultDirty.error.message);
+    } else if (vaultDirty.value.length > 0) {
+      result.contentDirty = vaultDirty.value;
+    }
+    const unstaged = this.gitDiffFiles(`${vaultPath}/`);
+    const staged = this.gitDiffFiles(`${vaultPath}/`, true);
+    if (!unstaged.ok) {
+      result.clean = false;
+      result.errors.push(unstaged.error.message);
+    }
+    if (!staged.ok) {
+      result.clean = false;
+      result.errors.push(staged.error.message);
+    }
+    if (unstaged.ok && staged.ok && unstaged.value.length > 0 && staged.value.length > 0) {
+      const both = unstaged.value.filter((f) => staged.value.includes(f));
+      if (both.length > 0) {
+        result.unstagedStagedOverlap = both;
+      }
+    }
+    const untracked = this.gitUntrackedFiles(`${obsidianConfigDir}/`);
+    if (!untracked.ok) {
+      result.clean = false;
+      result.errors.push(untracked.error.message);
+    } else if (untracked.value.length > 0) {
+      result.untracked = untracked.value;
+    }
+    return result;
+  }
+  restoreConfig(obsidianConfigDir) {
+    return this.git.restoreFromHead(`${obsidianConfigDir}/`);
+  }
+  gitDirtyFiles(pattern, _vaultPath, excludePattern) {
+    const args = ["diff", "--name-only", "--", pattern];
+    if (excludePattern) args.push(excludePattern);
+    const r = this.git.exec(args);
+    if (!r.ok) {
+      return {
+        ok: false,
+        error: {
+          code: "GIT_ERROR",
+          message: `Failed to inspect dirty files for ${pattern}`,
+          exitCode: 1,
+          gitCommand: `git ${args.join(" ")}`,
+          gitStderr: r.error
+        }
+      };
+    }
+    return { ok: true, value: r.output.split(/\r?\n/).filter(Boolean) };
+  }
+  gitDiffFiles(pattern, cached = false) {
+    const args = ["diff", "--name-only"];
+    if (cached) args.push("--cached");
+    args.push("--", pattern);
+    const r = this.git.exec(args);
+    if (!r.ok) {
+      return {
+        ok: false,
+        error: {
+          code: "GIT_ERROR",
+          message: `Failed to inspect diff files for ${pattern}`,
+          exitCode: 1,
+          gitCommand: `git ${args.join(" ")}`,
+          gitStderr: r.error
+        }
+      };
+    }
+    return { ok: true, value: r.output.split(/\r?\n/).filter(Boolean) };
+  }
+  gitUntrackedFiles(pattern) {
+    const r = this.git.exec(["ls-files", "--others", "--exclude-standard", "--", pattern]);
+    if (!r.ok) {
+      return {
+        ok: false,
+        error: {
+          code: "GIT_ERROR",
+          message: `Failed to inspect untracked files for ${pattern}`,
+          exitCode: 1,
+          gitCommand: `git ls-files --others --exclude-standard -- ${pattern}`,
+          gitStderr: r.error
+        }
+      };
+    }
+    return { ok: true, value: r.output.split(/\r?\n/).filter(Boolean) };
+  }
+};
+function createVaultGuard(git) {
+  return new VaultGuard(git);
+}
+
+// src/core/portfolio.service.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { isAbsolute, join as join4, resolve } from "path";
+
+// src/types/schemas.ts
+import { z } from "zod";
+var TaskHistoryEntrySchema = z.object({
+  at: z.string(),
+  action: z.string(),
+  operator: z.string().optional(),
+  from: z.string().optional(),
+  to: z.string().optional(),
+  reason: z.string().optional(),
+  branch: z.string().optional(),
+  description: z.string().optional()
+});
+var TaskSchema = z.object({
+  id: z.string().min(1).max(120),
+  title: z.string().min(1).max(500),
+  owner: z.string().min(1).max(50),
+  backupOwner: z.string().optional(),
+  status: z.enum(["ready", "active", "pending", "blocked", "done", "rolled_back"]),
+  track: z.string().optional(),
+  zone: z.array(z.string()).optional(),
+  dependsOn: z.array(z.string()).optional(),
+  acceptance: z.array(z.string()).optional(),
+  handoff: z.string().optional(),
+  history: z.array(TaskHistoryEntrySchema).optional()
+});
+var ReassignmentSchema = z.object({
+  at: z.string(),
+  task: z.string(),
+  from: z.string(),
+  to: z.string(),
+  reason: z.string()
+});
+var TaskBoardSchema = z.object({
+  project: z.string(),
+  updatedAt: z.string(),
+  resiliencePolicy: z.string().optional(),
+  closurePolicy: z.string().optional(),
+  baseTestMatrix: z.array(z.string()).optional(),
+  currentExecutionOrder: z.array(z.string()),
+  tasks: z.array(TaskSchema),
+  reassignments: z.array(ReassignmentSchema).optional()
+});
+var MotherBranchEntrySchema = z.object({
+  version: z.number(),
+  name: z.string(),
+  sprint: z.string(),
+  operator: z.string(),
+  date: z.string(),
+  at: z.string(),
+  previous: z.string(),
+  description: z.string()
+});
+var MotherVersionSchema = z.object({
+  version: z.number(),
+  current: z.string(),
+  branches: z.array(MotherBranchEntrySchema)
+});
+var ZoneEntrySchema = z.object({
+  owner: z.string(),
+  lock: z.enum(["operator_exclusive", "operator_double", "shared", "forbidden", "owner_per_sprint"]),
+  sprints: z.array(z.string()),
+  criticality: z.enum(["low", "medium", "high", "critical"]).optional()
+});
+var ZoneMapSchema = z.object({
+  zones: z.record(z.string(), ZoneEntrySchema)
+});
+var DerivedDocConfigSchema = z.object({
+  path: z.string().min(1),
+  type: z.enum(["central", "collaborator", "status-board"]),
+  source: z.literal("task-board"),
+  filter: z.object({ owner: z.string() }).optional(),
+  extra: z.record(z.string()).optional()
+});
+var CanonicalIssueSchema = z.object({
+  file: z.string(),
+  severity: z.enum(["blocker", "warn"]),
+  reason: z.string()
+});
+var GateDefinitionSchema = z.object({
+  name: z.string().min(1).max(100),
+  command: z.string().min(1).max(500),
+  args: z.array(z.string()).optional(),
+  timeoutSeconds: z.number().min(10).max(3600).default(300)
+});
+var OreshnikConfigSchema = z.object({
+  version: z.literal(1),
+  project: z.object({
+    name: z.string().min(1).max(100),
+    mainBranch: z.string().min(1).max(100).default("main")
+  }),
+  operators: z.array(z.object({
+    id: z.string().regex(/^[a-z0-9_-]+$/),
+    name: z.string().min(1).max(100),
+    email: z.string().email().optional()
+  })).min(1),
+  branching: z.object({
+    motherPrefix: z.string().default("MADRE"),
+    childFormat: z.string().default("{operator}/{sprint}-{desc}-{date}"),
+    integrationPrefix: z.string().default("integration")
+  }).optional().default({}),
+  validation: z.object({
+    gates: z.array(GateDefinitionSchema).default([])
+  }).optional().default({}),
+  hardStops: z.object({
+    forbiddenPatterns: z.array(z.string()).default([]),
+    doubleLockPatterns: z.array(z.string()).default([])
+  }).optional().default({}),
+  vault: z.object({
+    enabled: z.boolean().default(true),
+    path: z.string().default("docs/obsidian-vault"),
+    centralDoc: z.string().default("00_CENTRAL.md")
+  }).optional().default({}),
+  canonical: z.object({
+    derivedDocs: z.array(DerivedDocConfigSchema).optional(),
+    knownLegacyTasks: z.array(z.string()).optional(),
+    knownAssignmentTasks: z.array(z.string()).optional()
+  }).optional(),
+  sync: z.object({
+    canonicalAutoConflicts: z.array(z.string()).optional()
+  }).optional(),
+  checkpoints: z.object({
+    autoOnClose: z.boolean().default(true),
+    autoPreRollback: z.boolean().default(true),
+    snapshotDir: z.string().default("var/oreshnik/checkpoints")
+  }).optional().default({}),
+  security: z.object({
+    requireCleanTree: z.boolean().default(true),
+    secretScanning: z.boolean().default(true),
+    blockEnvDiffs: z.boolean().default(true)
+  }).optional().default({})
+});
+var PortfolioProjectSchema = z.object({
+  projectId: z.string().min(1).max(50).regex(/^[a-z0-9_-]+$/),
+  displayName: z.string().min(1).max(100),
+  repoPath: z.string().min(1),
+  defaultBranch: z.string().min(1).max(100),
+  operators: z.array(z.string().min(1).max(50)).default([]),
+  taskBoardPath: z.string().min(1).default("var/oreshnik/task-board.json"),
+  zoneMapPath: z.string().min(1).default("docs/07_handoffs/zone-map.json"),
+  validationGates: z.array(GateDefinitionSchema).default([]),
+  injectionPolicy: z.enum(["proposal_only", "direct_with_approval"]).default("proposal_only"),
+  priority: z.enum(["low", "medium", "high", "critical"]).default("medium")
+});
+var PortfolioConfigSchema = z.object({
+  version: z.literal(1),
+  portfolio: z.object({
+    id: z.string().min(1).max(50).regex(/^[a-z0-9_-]+$/),
+    name: z.string().min(1).max(100),
+    sourceNote: z.string().optional(),
+    continuityDocPath: z.string().min(1).optional()
+  }),
+  projects: z.array(PortfolioProjectSchema).min(1)
+});
+var DistributedLockSchema = z.object({
+  zone: z.string().min(1),
+  owner: z.string().min(1),
+  acquiredAt: z.string(),
+  expiresAt: z.string(),
+  ttlMinutes: z.number().min(1).max(1440),
+  sprint: z.string().optional(),
+  reason: z.string().min(1).max(500)
+});
+var CheckpointSchema = z.object({
+  id: z.string(),
+  tag: z.string(),
+  timestamp: z.string(),
+  operator: z.string(),
+  sprint: z.string().optional(),
+  type: z.enum(["auto", "manual", "pre-rollback"]),
+  git: z.object({
+    tag: z.string(),
+    commit: z.string(),
+    branch: z.string(),
+    motherBranch: z.string().optional(),
+    motherVersion: z.number().optional()
+  }),
+  state: z.object({
+    taskBoard: TaskBoardSchema,
+    motherVersion: MotherVersionSchema,
+    workingTreeDirty: z.boolean(),
+    stashRef: z.string().nullable()
+  }),
+  validation: z.object({
+    typecheck: z.enum(["passed", "failed", "skipped"]).optional(),
+    build: z.enum(["passed", "failed", "skipped"]).optional(),
+    tests: z.string().optional(),
+    zoneCheck: z.enum(["clean", "violations"]).optional(),
+    canonicalCheck: z.enum(["aligned", "drift"]).optional()
+  }).optional()
+});
+var SprintEventSchema = z.object({
+  sprint: z.string(),
+  operator: z.string(),
+  type: z.enum(["created", "started", "checkpoint", "gate_passed", "gate_failed", "closed", "rolled_back", "reassigned"]),
+  date: z.string(),
+  at: z.string(),
+  branch: z.string().optional(),
+  previousMother: z.string().optional(),
+  nextMother: z.string().optional(),
+  description: z.string().optional(),
+  changedFiles: z.array(z.string()).optional(),
+  gateResults: z.record(z.enum(["passed", "failed"])).optional()
+});
+var SprintIdSchema = z.string().min(1).max(50).regex(
+  /^[a-zA-Z0-9_-]+$/,
+  "Sprint ID must contain only alphanumeric characters, hyphens, and underscores"
+);
+var OperatorIdSchema = z.string().min(1).max(50).regex(
+  /^[a-zA-Z0-9_-]+$/,
+  "Operator ID must contain only alphanumeric characters, hyphens, and underscores"
+);
+var DescriptionSchema = z.string().min(1).max(500);
+var TagNameSchema = z.string().min(1).max(100).regex(
+  /^[a-zA-Z0-9._/-]+$/,
+  "Tag name must contain only alphanumeric characters, dots, underscores, hyphens, and slashes"
+);
+var VaultGuardResultSchema = z.object({
+  clean: z.boolean(),
+  configDirty: z.array(z.string()),
+  configRestored: z.boolean(),
+  contentDirty: z.array(z.string()),
+  unstagedStagedOverlap: z.array(z.string()),
+  untracked: z.array(z.string()),
+  errors: z.array(z.string())
+});
+var NoteTaskSchema = z.object({
+  rawLine: z.string(),
+  lineNumber: z.number(),
+  checked: z.boolean(),
+  projectIds: z.array(z.string()),
+  proposedType: z.enum(["feature", "bug", "qa", "docs", "architecture", "migration", "ops"]),
+  proposedOwner: z.string(),
+  proposedPriority: z.enum(["low", "medium", "high", "critical"]),
+  proposedSprintPrefix: z.string(),
+  evidenceType: z.enum(["code", "ui", "docs", "integration", "prod"]),
+  evidenceExpectation: z.string()
+});
+var NotesIngestionResultSchema = z.object({
+  sourcePath: z.string(),
+  portfolioId: z.string(),
+  parsedAt: z.string(),
+  dryRun: z.boolean(),
+  totalLines: z.number(),
+  taskLines: z.number(),
+  pendingCount: z.number(),
+  doneCount: z.number(),
+  tasksByProject: z.record(z.string(), z.array(NoteTaskSchema)),
+  unclassifiedTasks: z.array(NoteTaskSchema),
+  warnings: z.array(z.string())
+});
+var ProjectInjectionResultSchema = z.object({
+  projectId: z.string(),
+  displayName: z.string(),
+  injectionPolicy: z.enum(["proposal_only", "direct_with_approval"]),
+  repoPath: z.string(),
+  tasksInjected: z.number(),
+  tasksSkipped: z.number(),
+  checkpointTag: z.string().optional(),
+  handoffPath: z.string().optional(),
+  proposalPath: z.string().optional(),
+  blocked: z.boolean(),
+  blockReason: z.string().optional(),
+  warnings: z.array(z.string())
+});
+var InjectionResultSchema = z.object({
+  portfolioId: z.string(),
+  injectedAt: z.string(),
+  dryRun: z.boolean(),
+  confirmed: z.boolean(),
+  projects: z.array(ProjectInjectionResultSchema),
+  summary: z.object({
+    totalProjects: z.number(),
+    projectsBlocked: z.number(),
+    projectsInjected: z.number(),
+    proposalsGenerated: z.number(),
+    totalTasksInjected: z.number(),
+    totalTasksSkipped: z.number()
+  }),
+  errors: z.array(z.string())
+});
+var EvidenceRecordSchema = z.object({
+  taskId: z.string(),
+  evidenceType: z.enum(["code", "ui", "docs", "integration", "prod"]),
+  validatedAt: z.string(),
+  validator: z.string(),
+  result: z.enum(["passed", "failed", "pending"]),
+  details: z.string(),
+  artifacts: z.array(z.string()).optional()
+});
+var TaskEvidenceCheckSchema = z.object({
+  taskId: z.string(),
+  taskTitle: z.string(),
+  evidenceType: z.enum(["code", "ui", "docs", "integration", "prod"]),
+  hasEvidence: z.boolean(),
+  requiredEvidence: z.string(),
+  currentStatus: z.enum(["ready", "active", "pending", "blocked", "done", "rolled_back"]),
+  missing: z.array(z.string())
+});
+var EvidenceGateResultSchema = z.object({
+  checkedAt: z.string(),
+  sprint: z.string().optional(),
+  operator: z.string(),
+  totalTasks: z.number(),
+  doneTasks: z.number(),
+  tasksWithEvidence: z.number(),
+  tasksWithoutEvidence: z.number(),
+  tasks: z.array(TaskEvidenceCheckSchema),
+  passed: z.boolean(),
+  blockers: z.array(z.string())
+});
+var ZoneLockSchema = z.object({
+  zone: z.string(),
+  operator: z.string(),
+  sprint: z.string(),
+  acquiredAt: z.string(),
+  ttl: z.number().min(60).max(86400),
+  expiresAt: z.string()
+});
+var LockResultSchema = z.object({
+  zone: z.string(),
+  acquired: z.boolean(),
+  existingLock: ZoneLockSchema.optional(),
+  error: z.string().optional()
+});
+var LockListSchema = z.object({
+  fetchedAt: z.string(),
+  locks: z.array(ZoneLockSchema),
+  active: z.array(ZoneLockSchema),
+  expired: z.array(ZoneLockSchema)
+});
+
+// src/core/portfolio.service.ts
+var PortfolioService = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  load(configPath = ".oreshnik.portfolio.json") {
+    const fullPath = this.resolvePath(configPath);
+    if (!existsSync2(fullPath)) {
+      return err(this.fail(`Portfolio config not found: ${configPath}`));
+    }
+    try {
+      const raw = JSON.parse(readFileSync2(fullPath, "utf8").replace(/^\uFEFF/, ""));
+      const parsed = PortfolioConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        return err(this.fail(`Invalid portfolio config: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`));
+      }
+      return ok(parsed.data);
+    } catch (e) {
+      return err(this.fail(`Failed to read portfolio config ${configPath}: ${String(e)}`));
+    }
+  }
+  inspect(configPath = ".oreshnik.portfolio.json") {
+    const config = this.load(configPath);
+    if (!config.ok) return config;
+    const projects = config.value.projects.map((project) => this.inspectProject(project));
+    return ok({
+      configPath,
+      portfolioId: config.value.portfolio.id,
+      portfolioName: config.value.portfolio.name,
+      projectCount: config.value.projects.length,
+      continuityDocPath: config.value.portfolio.continuityDocPath,
+      projects
+    });
+  }
+  inspectProject(project) {
+    const repoPath = this.resolvePath(project.repoPath);
+    const repoExists = existsSync2(repoPath);
+    const taskBoardExists = repoExists && existsSync2(join4(repoPath, ...project.taskBoardPath.split("/")));
+    const zoneMapExists = repoExists && existsSync2(join4(repoPath, ...project.zoneMapPath.split("/")));
+    const warnings = [];
+    if (!repoExists) warnings.push("repo path not found");
+    if (repoExists && !taskBoardExists) warnings.push("task-board missing");
+    if (repoExists && !zoneMapExists) warnings.push("zone-map missing");
+    if (project.validationGates.length === 0) warnings.push("validation gates missing");
+    if (project.injectionPolicy === "direct_with_approval" && !taskBoardExists) warnings.push("direct injection blocked until task-board exists");
+    return {
+      projectId: project.projectId,
+      displayName: project.displayName,
+      repoPath: project.repoPath,
+      repoExists,
+      taskBoardExists,
+      zoneMapExists,
+      validationGateCount: project.validationGates.length,
+      injectionPolicy: project.injectionPolicy,
+      warnings
+    };
+  }
+  resolvePath(path) {
+    return isAbsolute(path) ? path : resolve(this.root, path);
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createPortfolioService(root) {
+  return new PortfolioService(root);
+}
+
+// src/core/notes-ingestion.service.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+var PROJECT_KEYWORDS = {
+  heptacore: ["heptacore", "heptacor", "eptacor"],
+  oreshnik: ["oreshnik", "oresnick", "ornik"],
+  turpialsound: ["turpialsound", "turpial sound", "turpial zone"],
+  turpialmarket: ["turpialmarket", "turpial market", "marketplace"],
+  dropsocial: ["dropsocial", "drop social"],
+  smsmantis: ["mantis", "smsmantis"]
+};
+var OPERATOR_KEYWORDS = {
+  jean: "jean"
+};
+var TASK_LINE_RE = /^\s*[-*]\s+\[([ xX])\]\s+(.+)$/;
+var NotesIngestionService = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  ingest(options) {
+    const configResult = this.loadPortfolio(options.configPath);
+    if (!configResult.ok) return configResult;
+    const config = configResult.value;
+    const fullSourcePath = this.resolvePath(options.sourcePath);
+    if (!existsSync3(fullSourcePath)) {
+      return err(this.fail(`Source file not found: ${options.sourcePath}`));
+    }
+    let content;
+    try {
+      content = readFileSync3(fullSourcePath, "utf8");
+    } catch (e) {
+      return err(this.fail(`Failed to read source file: ${String(e)}`));
+    }
+    const lines = content.split("\n");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const validProjectIds = new Set(config.projects.map((p) => p.projectId));
+    const allTasks = [];
+    const warnings = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line) continue;
+      const match = line.match(TASK_LINE_RE);
+      if (!match) continue;
+      const checked = match[1].toLowerCase() === "x";
+      const rawLine = match[2].trim();
+      if (!rawLine) continue;
+      const projectIds = this.classifyProject(rawLine, validProjectIds);
+      const proposedOwner = this.classifyOwner(rawLine);
+      const proposedType = this.classifyTaskType(rawLine);
+      const proposedPriority = this.classifyPriority(rawLine);
+      const proposedSprintPrefix = this.resolveSprintPrefix(projectIds);
+      const evidence = this.classifyEvidence(rawLine);
+      const task = {
+        rawLine,
+        lineNumber: i + 1,
+        checked,
+        projectIds,
+        proposedType,
+        proposedOwner,
+        proposedPriority,
+        proposedSprintPrefix,
+        evidenceType: evidence.type,
+        evidenceExpectation: evidence.expectation
+      };
+      allTasks.push(task);
+      if (projectIds.length === 0) {
+        warnings.push(`Line ${i + 1}: could not classify project for task, moved to unclassified`);
+      }
+    }
+    const tasksByProject = {};
+    for (const pid of validProjectIds) {
+      tasksByProject[pid] = [];
+    }
+    const unclassifiedTasks = [];
+    for (const task of allTasks) {
+      if (task.projectIds.length === 0) {
+        unclassifiedTasks.push(task);
+        continue;
+      }
+      for (const pid of task.projectIds) {
+        if (validProjectIds.has(pid) && tasksByProject[pid]) {
+          tasksByProject[pid].push(task);
+        }
+      }
+    }
+    const pendingTasks = allTasks.filter((t) => !t.checked);
+    const doneTasks = allTasks.filter((t) => t.checked);
+    const result = {
+      sourcePath: options.sourcePath,
+      portfolioId: config.portfolio.id,
+      parsedAt: now,
+      dryRun: options.dryRun !== false,
+      totalLines: lines.length,
+      taskLines: allTasks.length,
+      pendingCount: pendingTasks.length,
+      doneCount: doneTasks.length,
+      tasksByProject,
+      unclassifiedTasks,
+      warnings
+    };
+    const parsed = NotesIngestionResultSchema.safeParse(result);
+    if (!parsed.success) {
+      return err(this.fail(`Invalid ingestion result: ${parsed.error.message}`));
+    }
+    return ok(result);
+  }
+  loadPortfolio(configPath = ".oreshnik.portfolio.json") {
+    const fullPath = this.resolvePath(configPath);
+    if (!existsSync3(fullPath)) {
+      return err(this.fail(`Portfolio config not found: ${configPath}`));
+    }
+    try {
+      const raw = JSON.parse(readFileSync3(fullPath, "utf8").replace(/^\uFEFF/, ""));
+      const parsed = PortfolioConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        return err(this.fail(`Invalid portfolio config: ${parsed.error.message}`));
+      }
+      return ok(parsed.data);
+    } catch (e) {
+      return err(this.fail(`Failed to read portfolio config: ${String(e)}`));
+    }
+  }
+  classifyProject(text, validIds) {
+    const lower = text.toLowerCase();
+    const ids = [];
+    for (const [pid, keywords] of Object.entries(PROJECT_KEYWORDS)) {
+      if (!validIds.has(pid)) continue;
+      for (const kw of keywords) {
+        if (lower.includes(kw)) {
+          ids.push(pid);
+          break;
+        }
+      }
+    }
+    return ids;
+  }
+  classifyOwner(text) {
+    const lower = text.toLowerCase();
+    for (const [keyword, owner] of Object.entries(OPERATOR_KEYWORDS)) {
+      if (lower.includes(keyword)) return owner;
+    }
+    return "architect";
+  }
+  classifyTaskType(text) {
+    const lower = text.toLowerCase();
+    if (/\bbug\b|error|falla|roto|corregir|arreglar|fix\b/.test(lower)) return "bug";
+    if (/revisar\b|qa\b|test\b|validar\b|verificar\b/.test(lower)) return "qa";
+    if (/documentar\b|doc\b|gu[ií]a\b|readme|notas\b/.test(lower)) return "docs";
+    if (/arquitectura|dise[ñn]o\b|estructura|decisi[óo]n/.test(lower)) return "architecture";
+    if (/separar\b|mover\b|migrar\b|aislar\b|extraer|split/.test(lower)) return "migration";
+    if (/publicar\b|deploy\b|producci[óo]n|server|entorno/.test(lower)) return "ops";
+    return "feature";
+  }
+  classifyPriority(text) {
+    const lower = text.toLowerCase();
+    if (/cr[ií]tico|urgente|bloquea|crash\b|roto\b|prioridad alta/.test(lower)) return "critical";
+    if (/importante|alto impacto|prioridad/.test(lower)) return "high";
+    if (/bajo|menor|opcional|low priority/.test(lower)) return "low";
+    return "medium";
+  }
+  resolveSprintPrefix(projectIds) {
+    const prefixes = {
+      heptacore: "S-HC",
+      oreshnik: "S-ORESHNIK",
+      turpialsound: "S-TS",
+      turpialmarket: "S-TM",
+      dropsocial: "S-DS",
+      smsmantis: "S-SM"
+    };
+    for (const pid of projectIds) {
+      if (prefixes[pid]) return prefixes[pid];
+    }
+    return "S-GEN";
+  }
+  classifyEvidence(text) {
+    const lower = text.toLowerCase();
+    if (/implementar|crear\b|construir|c[óo]digo|funcionalidad|backend|api\b|endpoint/.test(lower)) {
+      return { type: "code", expectation: "diff verificable, tests" };
+    }
+    if (/click|bot[óo]n|tarjeta|card\b|ui\b|dashboard|modal|interfaz|visual|landing|p[áa]gina/.test(lower)) {
+      return { type: "ui", expectation: "QA manual o test automatizado de UI" };
+    }
+    if (/documentar|doc\b|leer\b|documentaci[óo]n|gu[ií]a|readme/.test(lower)) {
+      return { type: "docs", expectation: "documentos actualizados en vault" };
+    }
+    if (/integrar|conectar|webhook|deploy\b|publicar|producci[óo]n/.test(lower)) {
+      return { type: "integration", expectation: "dry-run verificable o test e2e" };
+    }
+    if (/producci[óo]n\b|release\b|publish\b|lanzar/.test(lower)) {
+      return { type: "prod", expectation: "checklist manual, rollback plan y confirmaci[\xF3o]n humana" };
+    }
+    return { type: "code", expectation: "diff verificable" };
+  }
+  resolvePath(path) {
+    return isAbsolute2(path) ? path : resolve2(this.root, path);
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createNotesIngestionService(root) {
+  return new NotesIngestionService(root);
+}
+
+// src/core/injection.service.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { isAbsolute as isAbsolute3, join as join5, resolve as resolve3 } from "path";
+
+// src/utils/helpers.ts
+function sanitize(value, maxLength = 48) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLength);
+}
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function nowDisplay(timeZone = "America/Caracas") {
+  const now = /* @__PURE__ */ new Date();
+  const formatter = new Intl.DateTimeFormat("es-VE", {
+    timeZone,
+    year: "2-digit",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  return {
+    display: formatter.format(now).replace(",", ""),
+    iso: now.toISOString(),
+    date: now.toISOString().slice(0, 10)
+  };
+}
+function formatBranchName(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(`{${key}}`, sanitize(value));
+  }
+  return result;
+}
+function nonIgnoredDirtyFiles(porcelain) {
+  return porcelain.filter((entry) => !entry.path.startsWith("var/oreshnik/") && !entry.path.startsWith("output/")).map((entry) => entry.path);
+}
+function isMotherBranch(branch) {
+  return /^(main|master|MADRE\/|integration\/|prod\/)/i.test(branch);
+}
+function isChildBranch(branch, operator) {
+  return new RegExp(`^${operator}/`, "i").test(branch);
+}
+
+// src/core/injection.service.ts
+var InjectionService = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  inject(options) {
+    const configResult = this.loadPortfolio(options.configPath);
+    if (!configResult.ok) return configResult;
+    const config = configResult.value;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const projectResults = [];
+    const errors = [];
+    const projectsToProcess = options.projectFilter ? config.projects.filter((p) => options.projectFilter.includes(p.projectId)) : config.projects;
+    for (const project of projectsToProcess) {
+      const tasks = options.ingestion.tasksByProject[project.projectId];
+      if (!tasks || tasks.length === 0) continue;
+      const pendingTasks = tasks.filter((t) => !t.checked);
+      if (pendingTasks.length === 0) continue;
+      const result2 = this.injectIntoProject(project, pendingTasks, options);
+      projectResults.push(result2);
+      if (result2.blocked && result2.blockReason) {
+        errors.push(`${project.projectId}: ${result2.blockReason}`);
+      }
+    }
+    const blocked = projectResults.filter((r) => r.blocked);
+    const injected = projectResults.filter((r) => !r.blocked && r.injectionPolicy === "direct_with_approval");
+    const proposals = projectResults.filter((r) => !r.blocked && r.injectionPolicy === "proposal_only");
+    const summary = {
+      totalProjects: projectResults.length,
+      projectsBlocked: blocked.length,
+      projectsInjected: injected.length,
+      proposalsGenerated: proposals.length,
+      totalTasksInjected: injected.reduce((sum, r) => sum + r.tasksInjected, 0),
+      totalTasksSkipped: projectResults.reduce((sum, r) => sum + r.tasksSkipped, 0)
+    };
+    const result = {
+      portfolioId: config.portfolio.id,
+      injectedAt: now,
+      dryRun: options.dryRun !== false,
+      confirmed: options.confirm === true,
+      projects: projectResults,
+      summary,
+      errors
+    };
+    const parsed = InjectionResultSchema.safeParse(result);
+    if (!parsed.success) {
+      return err(this.fail(`Invalid injection result: ${parsed.error.message}`));
+    }
+    return ok(result);
+  }
+  injectIntoProject(project, tasks, options) {
+    const repoPath = this.resolveProjectPath(project.repoPath);
+    const warnings = [];
+    if (!existsSync4(repoPath)) {
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        injectionPolicy: project.injectionPolicy,
+        repoPath: project.repoPath,
+        tasksInjected: 0,
+        tasksSkipped: 0,
+        blocked: true,
+        blockReason: "repo path not found",
+        warnings
+      };
+    }
+    if (project.injectionPolicy === "proposal_only") {
+      const proposal = this.generateProposal(project, tasks, options.dryRun !== false);
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        injectionPolicy: "proposal_only",
+        repoPath: project.repoPath,
+        tasksInjected: 0,
+        tasksSkipped: 0,
+        proposalPath: proposal,
+        blocked: false,
+        warnings
+      };
+    }
+    if (project.injectionPolicy === "direct_with_approval") {
+      if (!options.confirm) {
+        return {
+          projectId: project.projectId,
+          displayName: project.displayName,
+          injectionPolicy: "direct_with_approval",
+          repoPath: project.repoPath,
+          tasksInjected: 0,
+          tasksSkipped: 0,
+          blocked: true,
+          blockReason: "confirmation required (use --confirm)",
+          warnings
+        };
+      }
+      const zoneMapPath = join5(repoPath, ...project.zoneMapPath.split("/"));
+      if (!existsSync4(zoneMapPath)) {
+        return {
+          projectId: project.projectId,
+          displayName: project.displayName,
+          injectionPolicy: "direct_with_approval",
+          repoPath: project.repoPath,
+          tasksInjected: 0,
+          tasksSkipped: 0,
+          blocked: true,
+          blockReason: "zone-map missing",
+          warnings
+        };
+      }
+      let zoneOperators = [];
+      try {
+        const zoneRaw = JSON.parse(readFileSync4(zoneMapPath, "utf8").replace(/^\uFEFF/, ""));
+        const owners = /* @__PURE__ */ new Set();
+        for (const [, zone] of Object.entries(zoneRaw.zones || {})) {
+          const lock = zone.lock || "";
+          const owner = zone.owner || "";
+          if (lock.includes("exclusive") || lock === "operator_double") {
+            if (owner) owners.add(owner);
+          }
+        }
+        if (owners.size === 0) {
+          for (const op of project.operators || []) {
+            owners.add(op);
+          }
+        }
+        zoneOperators = [...owners].filter((o) => o && o !== "none");
+      } catch {
+        zoneOperators = [];
+      }
+      if (zoneOperators.length === 0) {
+        zoneOperators = project.operators?.length ? project.operators : ["architect"];
+      }
+      const getOwner = (taskIndex2) => {
+        return zoneOperators[taskIndex2 % zoneOperators.length] || "architect";
+      };
+      const git = new GitService(repoPath);
+      const statusResult = git.statusPorcelain();
+      if (statusResult.ok && statusResult.value.length > 0) {
+        return {
+          projectId: project.projectId,
+          displayName: project.displayName,
+          injectionPolicy: "direct_with_approval",
+          repoPath: project.repoPath,
+          tasksInjected: 0,
+          tasksSkipped: 0,
+          blocked: true,
+          blockReason: `working tree dirty (${statusResult.value.length} files)`,
+          warnings
+        };
+      }
+      if (options.dryRun !== false) {
+        return {
+          projectId: project.projectId,
+          displayName: project.displayName,
+          injectionPolicy: "direct_with_approval",
+          repoPath: project.repoPath,
+          tasksInjected: tasks.length,
+          tasksSkipped: 0,
+          blocked: false,
+          warnings: ["dry-run: no task-board was modified"]
+        };
+      }
+      const checkpointTag = this.createPreInjectionCheckpoint(git, project);
+      const checkpointResult = git.createTag(checkpointTag, `pre-injection checkpoint for ${project.projectId}`);
+      if (!checkpointResult.ok) {
+        warnings.push(`checkpoint creation failed: ${checkpointResult.error.message}`);
+      }
+      const state = new StateManager(repoPath);
+      const taskBoardPath = join5(repoPath, ...project.taskBoardPath.split("/"));
+      const existingBoard = state.readJson(taskBoardPath);
+      const board = existingBoard.ok ? existingBoard.value : {
+        project: project.projectId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        currentExecutionOrder: [],
+        tasks: []
+      };
+      let injected = 0;
+      let skipped = 0;
+      let taskIndex = 0;
+      for (const noteTask of tasks) {
+        const taskId = this.generateTaskId(noteTask);
+        const existingTask = board.tasks.find((t) => t.id === taskId);
+        if (existingTask) {
+          skipped++;
+          continue;
+        }
+        const owner = getOwner(taskIndex);
+        taskIndex++;
+        const task = {
+          id: taskId,
+          title: noteTask.rawLine.slice(0, 200),
+          owner,
+          status: "ready",
+          track: noteTask.proposedSprintPrefix,
+          zone: [],
+          acceptance: [noteTask.evidenceExpectation],
+          handoff: `docs/07_handoffs/handoff-${owner}-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.md`,
+          history: [
+            {
+              at: (/* @__PURE__ */ new Date()).toISOString(),
+              action: "injected",
+              operator: owner,
+              description: `Injected from notes ingestion. Evidence: ${noteTask.evidenceType}`
+            }
+          ]
+        };
+        board.tasks.push(task);
+        injected++;
+      }
+      board.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      board.currentExecutionOrder = [...board.currentExecutionOrder, ...tasks.map((t) => this.generateTaskId(t))];
+      const writeResult = state.writeJson(taskBoardPath, board);
+      if (!writeResult.ok) {
+        return {
+          projectId: project.projectId,
+          displayName: project.displayName,
+          injectionPolicy: "direct_with_approval",
+          repoPath: project.repoPath,
+          tasksInjected: 0,
+          tasksSkipped: 0,
+          blocked: true,
+          blockReason: `failed to write task-board: ${writeResult.error.message}`,
+          warnings
+        };
+      }
+      const handoffPath = this.generateHandoff(project, tasks, repoPath);
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        injectionPolicy: "direct_with_approval",
+        repoPath: project.repoPath,
+        tasksInjected: injected,
+        tasksSkipped: skipped,
+        checkpointTag: checkpointResult.ok ? checkpointTag : void 0,
+        handoffPath,
+        blocked: false,
+        warnings
+      };
+    }
+    return {
+      projectId: project.projectId,
+      displayName: project.displayName,
+      injectionPolicy: project.injectionPolicy,
+      repoPath: project.repoPath,
+      tasksInjected: 0,
+      tasksSkipped: 0,
+      blocked: true,
+      blockReason: `unknown injection policy: ${project.injectionPolicy}`,
+      warnings
+    };
+  }
+  generateProposal(project, tasks, dryRun) {
+    const repoPath = this.resolveProjectPath(project.repoPath);
+    const proposalDir = join5(repoPath, "var", "oreshnik");
+    mkdirSync2(proposalDir, { recursive: true });
+    const proposalPath = join5(proposalDir, "injection-proposal.json");
+    const proposal = {
+      projectId: project.projectId,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      dryRun,
+      injectionPolicy: "proposal_only",
+      proposedTasks: tasks.map((t) => ({
+        taskId: this.generateTaskId(t),
+        title: t.rawLine.slice(0, 200),
+        owner: t.proposedOwner,
+        priority: t.proposedPriority,
+        evidenceType: t.evidenceType,
+        evidenceExpectation: t.evidenceExpectation
+      }))
+    };
+    if (!dryRun) {
+      writeFileSync2(proposalPath, JSON.stringify(proposal, null, 2), "utf8");
+    }
+    return `var/oreshnik/injection-proposal.json`;
+  }
+  generateHandoff(project, tasks, repoPath) {
+    const handoffDir = join5(repoPath, "docs", "07_handoffs");
+    mkdirSync2(handoffDir, { recursive: true });
+    const owners = new Set(tasks.map((t) => t.proposedOwner));
+    for (const owner of owners) {
+      const ownerTasks = tasks.filter((t) => t.proposedOwner === owner);
+      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const handoffPath = join5(handoffDir, `handoff-${owner}-${date}.md`);
+      const lines = [
+        `# Handoff \u2014 ${owner}`,
+        `Date: ${date}`,
+        `Project: ${project.displayName} (${project.projectId})`,
+        ``,
+        `## Tasks Injected`,
+        ``
+      ];
+      for (const task of ownerTasks) {
+        lines.push(`- [ ] **${task.proposedSprintPrefix}** ${task.rawLine.slice(0, 150)}`);
+        lines.push(`  - Type: ${task.proposedType}`);
+        lines.push(`  - Priority: ${task.proposedPriority}`);
+        lines.push(`  - Evidence: ${task.evidenceType} \u2014 ${task.evidenceExpectation}`);
+        lines.push(``);
+      }
+      writeFileSync2(handoffPath, lines.join("\n"), "utf8");
+    }
+    return `docs/07_handoffs/`;
+  }
+  createPreInjectionCheckpoint(git, project) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    return `oreshnik/pre-inject-${project.projectId}-${timestamp}`;
+  }
+  generateTaskId(noteTask) {
+    const base = sanitize(noteTask.rawLine.slice(0, 48));
+    return base || `task-${Date.now()}`;
+  }
+  loadPortfolio(configPath = ".oreshnik.portfolio.json") {
+    const fullPath = this.resolveLocalPath(configPath);
+    if (!existsSync4(fullPath)) {
+      return err(this.fail(`Portfolio config not found: ${configPath}`));
+    }
+    try {
+      const raw = JSON.parse(readFileSync4(fullPath, "utf8").replace(/^\uFEFF/, ""));
+      const parsed = PortfolioConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        return err(this.fail(`Invalid portfolio config: ${parsed.error.message}`));
+      }
+      return ok(parsed.data);
+    } catch (e) {
+      return err(this.fail(`Failed to read portfolio config: ${String(e)}`));
+    }
+  }
+  resolveProjectPath(path) {
+    return isAbsolute3(path) ? path : resolve3(this.root, path);
+  }
+  resolveLocalPath(path) {
+    return isAbsolute3(path) ? path : resolve3(this.root, path);
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createInjectionService(root) {
+  return new InjectionService(root);
+}
+
+// src/core/evidence-gate.service.ts
+var EVIDENCE_REQUIREMENTS = {
+  code: {
+    minimum: "diff verificable, tests o build",
+    items: ["changed files diff", "typecheck passed", "tests passed"]
+  },
+  ui: {
+    minimum: "QA manual o test automatizado de UI",
+    items: ["UI change description", "screenshot or test result", "operator confirmation"]
+  },
+  docs: {
+    minimum: "documentos actualizados en vault",
+    items: ["updated doc paths", "references in vault", "canonical alignment check"]
+  },
+  integration: {
+    minimum: "dry-run verificable o test e2e",
+    items: ["integration test output", "dry-run summary", "endpoint verification"]
+  },
+  prod: {
+    minimum: "checklist manual, rollback plan y confirmacion humana",
+    items: ["deployment checklist", "rollback plan", "human approval signature"]
+  }
+};
+var EvidenceGateService = class {
+  check(taskBoard, operator, sprint) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const tasks = [];
+    const blockers = [];
+    let doneTasks = 0;
+    let tasksWithEvidence = 0;
+    let tasksWithoutEvidence = 0;
+    for (const task of taskBoard.tasks) {
+      if (task.status === "done") {
+        doneTasks++;
+      }
+      const evidenceType = this.inferEvidenceType(task);
+      const required = EVIDENCE_REQUIREMENTS[evidenceType];
+      const check = this.evaluateTaskEvidence(task, evidenceType, required);
+      tasks.push(check);
+      if (task.status === "done" && !check.hasEvidence) {
+        tasksWithoutEvidence++;
+        blockers.push(`${task.id}: ${check.missing.join("; ")}`);
+      } else if (task.status === "done" && check.hasEvidence) {
+        tasksWithEvidence++;
+      }
+    }
+    const result = {
+      checkedAt: now,
+      sprint,
+      operator,
+      totalTasks: taskBoard.tasks.length,
+      doneTasks,
+      tasksWithEvidence,
+      tasksWithoutEvidence,
+      tasks,
+      passed: blockers.length === 0,
+      blockers
+    };
+    const parsed = EvidenceGateResultSchema.safeParse(result);
+    if (!parsed.success) {
+      return err(this.fail(`Invalid evidence gate result: ${parsed.error.message}`));
+    }
+    return ok(result);
+  }
+  generateChecklist(taskBoard, operator) {
+    const lines = [
+      `# QA Evidence Checklist`,
+      `Operator: ${operator}`,
+      `Project: ${taskBoard.project}`,
+      `Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      ``,
+      `## Instructions`,
+      `Verify each task below. Mark [x] when evidence is confirmed. If a task lacks evidence, it will block sprint closure.`,
+      ``
+    ];
+    for (const task of taskBoard.tasks) {
+      if (task.status !== "done") continue;
+      const evidenceType = this.inferEvidenceType(task);
+      const required = EVIDENCE_REQUIREMENTS[evidenceType];
+      lines.push(`### ${task.id}`);
+      lines.push(`**Title:** ${task.title}`);
+      lines.push(`**Evidence Type:** ${evidenceType}`);
+      lines.push(`**Minimum Required:** ${required.minimum}`);
+      lines.push(``);
+      for (const item of required.items) {
+        lines.push(`- [ ] ${item}`);
+      }
+      lines.push(`- [ ] Operator confirms task is complete`);
+      lines.push(``);
+    }
+    return lines.join("\n");
+  }
+  evaluateTaskEvidence(task, evidenceType, required) {
+    const missing = [];
+    const hardMissing = [];
+    const history = task.history || [];
+    const acceptance = task.acceptance || [];
+    const hasValidation = history.some(
+      (h) => h.action === "validated" || h.action === "done" || h.action === "qa_passed"
+    );
+    if (!hasValidation) {
+      hardMissing.push("no validation history entry found");
+    }
+    if (acceptance.length === 0) {
+      hardMissing.push("no acceptance criteria defined");
+    }
+    if (task.status === "done" && !task.handoff) {
+      hardMissing.push("no handoff path defined");
+    }
+    if (task.status === "done") {
+      const combinedText = [...history.map((h) => h.description || ""), ...acceptance].join(" ").toLowerCase();
+      let matchedItems = 0;
+      for (const item of required.items) {
+        if (combinedText.includes(item.toLowerCase())) {
+          matchedItems++;
+        }
+      }
+      for (const item of required.items) {
+        if (!combinedText.includes(item.toLowerCase())) {
+          missing.push(`evidence item not verified: ${item}`);
+        }
+      }
+      if (matchedItems === 0) {
+        hardMissing.push("no evidence items matched the task");
+      }
+    }
+    const allMissing = [...hardMissing, ...missing];
+    return {
+      taskId: task.id,
+      taskTitle: task.title,
+      evidenceType,
+      hasEvidence: task.status !== "done" || hardMissing.length === 0,
+      requiredEvidence: required.minimum,
+      currentStatus: task.status,
+      missing: allMissing
+    };
+  }
+  inferEvidenceType(task) {
+    const text = `${task.title} ${task.track || ""} ${(task.acceptance || []).join(" ")}`.toLowerCase();
+    if (/ui\b|dashboard|modal|interfaz|visual|landing|p[áa]gina|card|bot[óo]n|click|css|style/.test(text)) return "ui";
+    if (/documentar|doc\b|gu[ií]a|readme|vault|notas/.test(text)) return "docs";
+    if (/integrar|conectar|webhook|deploy\b|publicar|api\b|endpoint/.test(text)) return "integration";
+    if (/producci[óo]n\b|release\b|publish\b|lanzar|prod\b/.test(text)) return "prod";
+    return "code";
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createEvidenceGateService() {
+  return new EvidenceGateService();
+}
+
+// src/core/bootstrap.service.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { isAbsolute as isAbsolute4, join as join6, resolve as resolve4 } from "path";
+var BootstrapService = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  bootstrap(configPath = ".oreshnik.portfolio.json", projectFilter) {
+    const configResult = this.loadPortfolio(configPath);
+    if (!configResult.ok) return configResult;
+    const config = configResult.value;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const projects = [];
+    const targets = projectFilter ? config.projects.filter((p) => projectFilter.includes(p.projectId)) : config.projects;
+    for (const project of targets) {
+      projects.push(this.bootstrapProject(project));
+    }
+    return ok({
+      portfolioId: config.portfolio.id,
+      bootstrappedAt: now,
+      projects
+    });
+  }
+  bootstrapProject(project) {
+    const repoPath = this.resolveProjectPath(project.repoPath);
+    const errors = [];
+    let taskBoardCreated = false;
+    let zoneMapCreated = false;
+    let gatesDocCreated = false;
+    if (!existsSync5(repoPath)) {
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        repoPath: project.repoPath,
+        repoExists: false,
+        taskBoardCreated: false,
+        zoneMapCreated: false,
+        gatesDocCreated: false,
+        errors: ["repo path not found"]
+      };
+    }
+    const varDir = join6(repoPath, "var", "oreshnik");
+    const handoffsDir = join6(repoPath, "docs", "07_handoffs");
+    const taskBoardPath = join6(repoPath, ...project.taskBoardPath.split("/"));
+    const zoneMapPath = join6(repoPath, ...project.zoneMapPath.split("/"));
+    try {
+      mkdirSync3(varDir, { recursive: true });
+      mkdirSync3(handoffsDir, { recursive: true });
+    } catch (e) {
+      errors.push(`failed to create directories: ${String(e)}`);
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        repoPath: project.repoPath,
+        repoExists: true,
+        taskBoardCreated: false,
+        zoneMapCreated: false,
+        gatesDocCreated: false,
+        errors
+      };
+    }
+    if (!existsSync5(taskBoardPath)) {
+      try {
+        const taskBoard = {
+          project: project.projectId,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          currentExecutionOrder: [],
+          tasks: []
+        };
+        writeFileSync3(taskBoardPath, JSON.stringify(taskBoard, null, 2) + "\n", "utf8");
+        taskBoardCreated = true;
+      } catch (e) {
+        errors.push(`failed to create task-board: ${String(e)}`);
+      }
+    }
+    if (!existsSync5(zoneMapPath)) {
+      try {
+        const zoneMap = {
+          zones: {
+            "docs/**": { owner: "shared", lock: "shared", sprints: ["*"] },
+            "var/oreshnik/**": { owner: "shared", lock: "shared", sprints: ["*"] },
+            "src/**": { owner: "architect", lock: "operator_exclusive", sprints: ["*"] },
+            ".env": { owner: "none", lock: "forbidden", sprints: ["*"], criticality: "critical" },
+            ".env.*": { owner: "none", lock: "forbidden", sprints: ["*"], criticality: "critical" }
+          }
+        };
+        writeFileSync3(zoneMapPath, JSON.stringify(zoneMap, null, 2) + "\n", "utf8");
+        zoneMapCreated = true;
+      } catch (e) {
+        errors.push(`failed to create zone-map: ${String(e)}`);
+      }
+    }
+    if (project.validationGates.length === 0) {
+      try {
+        const gatesDocPath = join6(repoPath, "var", "oreshnik", "gates.json");
+        const defaultGates = {
+          project: project.projectId,
+          gates: [
+            { name: "typecheck", command: "npm", args: ["run", "typecheck"], timeoutSeconds: 120 },
+            { name: "build", command: "npm", args: ["run", "build"], timeoutSeconds: 300 },
+            { name: "test", command: "npm", args: ["run", "test"], timeoutSeconds: 300 }
+          ]
+        };
+        writeFileSync3(gatesDocPath, JSON.stringify(defaultGates, null, 2) + "\n", "utf8");
+        gatesDocCreated = true;
+      } catch (e) {
+        errors.push(`failed to create gates doc: ${String(e)}`);
+      }
+    }
+    return {
+      projectId: project.projectId,
+      displayName: project.displayName,
+      repoPath: project.repoPath,
+      repoExists: true,
+      taskBoardCreated,
+      zoneMapCreated,
+      gatesDocCreated,
+      errors
+    };
+  }
+  loadPortfolio(configPath) {
+    const fullPath = this.resolveLocalPath(configPath);
+    if (!existsSync5(fullPath)) {
+      return err(this.fail(`Portfolio config not found: ${configPath}`));
+    }
+    try {
+      const raw = JSON.parse(readFileSync5(fullPath, "utf8").replace(/^\uFEFF/, ""));
+      const parsed = PortfolioConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        return err(this.fail(`Invalid portfolio config: ${parsed.error.message}`));
+      }
+      return ok(parsed.data);
+    } catch (e) {
+      return err(this.fail(`Failed to read portfolio config: ${String(e)}`));
+    }
+  }
+  resolveProjectPath(path) {
+    return isAbsolute4(path) ? path : resolve4(this.root, path);
+  }
+  resolveLocalPath(path) {
+    return isAbsolute4(path) ? path : resolve4(this.root, path);
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createBootstrapService(root) {
+  return new BootstrapService(root);
+}
+
+// src/core/dashboard.service.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { isAbsolute as isAbsolute5, join as join7, resolve as resolve5 } from "path";
+
+// src/core/lock.service.ts
+var LOCK_TAG_PREFIX = "oreshnik-lock/";
+var LockService = class {
+  git;
+  constructor(repoPath) {
+    this.git = new GitService(repoPath);
+  }
+  acquire(zone, operator, sprint, ttl = 3600) {
+    const sanitized = this.sanitizeRef(zone);
+    const existingResult = this.check(zone);
+    if (existingResult.ok && existingResult.value.active.length > 0) {
+      const existing = existingResult.value.active[0];
+      if (!existing) {
+        return err(this.fail("Unexpected: active lock array element is undefined"));
+      }
+      return ok({
+        zone,
+        acquired: false,
+        existingLock: existing,
+        error: `Zone locked by ${existing.operator} until ${existing.expiresAt}`
+      });
+    }
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(now.getTime() + ttl * 1e3);
+    const lock = {
+      zone,
+      operator,
+      sprint,
+      acquiredAt: now.toISOString(),
+      ttl,
+      expiresAt: expiresAt.toISOString()
+    };
+    const parsed = ZoneLockSchema.safeParse(lock);
+    if (!parsed.success) {
+      return err(this.fail(`Invalid lock: ${parsed.error.message}`));
+    }
+    const tagName = `${LOCK_TAG_PREFIX}${sanitized}`;
+    const annotation = JSON.stringify(parsed.data);
+    const tagResult = this.git.createTag(tagName, annotation);
+    if (!tagResult.ok) {
+      return err(this.fail(`Failed to create lock tag: ${tagResult.error.message}`));
+    }
+    const pushResult = this.git.exec(["push", "origin", tagName]);
+    if (!pushResult.ok) {
+      const msg = pushResult.error || pushResult.output || "unknown error";
+      if (typeof msg === "string" && (msg.includes("rejected") || msg.includes("failed"))) {
+        this.git.deleteTag(tagName);
+        return ok({
+          zone,
+          acquired: false,
+          error: "Failed to push lock: another operator may have acquired it"
+        });
+      }
+      this.git.deleteTag(tagName);
+      return err(this.fail(`Failed to push lock: ${msg}`));
+    }
+    return ok({ zone, acquired: true });
+  }
+  release(zone) {
+    const sanitized = this.sanitizeRef(zone);
+    const tagName = `${LOCK_TAG_PREFIX}${sanitized}`;
+    const deleteResult = this.git.exec(["push", "origin", `:refs/tags/${tagName}`]);
+    if (!deleteResult.ok) {
+      const msg = deleteResult.error || deleteResult.output || "unknown error";
+      return err(this.fail(`Failed to release lock: ${msg}`));
+    }
+    this.git.deleteTag(tagName);
+    return ok({ zone, acquired: false });
+  }
+  check(zone) {
+    const now = /* @__PURE__ */ new Date();
+    const locks = [];
+    const active = [];
+    const expired = [];
+    const fetchResult = this.git.exec(["ls-remote", "origin", `refs/tags/${LOCK_TAG_PREFIX}*`]);
+    if (!fetchResult.ok) {
+      return err(this.fail(`Failed to fetch locks: ${fetchResult.error || fetchResult.output}`));
+    }
+    const lines = (fetchResult.output || "").split("\n").filter(Boolean);
+    for (const line of lines) {
+      const parts = line.split("	");
+      if (parts.length < 2) continue;
+      const refName = parts[1];
+      if (!refName) continue;
+      const tagName = refName.replace("refs/tags/", "");
+      const contentResult = this.git.exec(["tag", "-l", "--format=%(contents)", tagName]);
+      if (!contentResult.ok || !contentResult.output) continue;
+      try {
+        const raw = JSON.parse(contentResult.output.trim());
+        const parsed = ZoneLockSchema.safeParse(raw);
+        if (!parsed.success) continue;
+        const lock = parsed.data;
+        locks.push(lock);
+        const expiresAt = new Date(lock.expiresAt);
+        if (expiresAt > now) {
+          active.push(lock);
+        } else {
+          expired.push(lock);
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (zone) {
+      const zoneActive = active.filter((l) => l.zone === zone);
+      const zoneExpired = expired.filter((l) => l.zone === zone);
+      return ok({
+        fetchedAt: now.toISOString(),
+        locks: [...zoneActive, ...zoneExpired],
+        active: zoneActive,
+        expired: zoneExpired
+      });
+    }
+    const result = {
+      fetchedAt: now.toISOString(),
+      locks,
+      active,
+      expired
+    };
+    const parsedResult = LockListSchema.safeParse(result);
+    if (!parsedResult.success) {
+      return err(this.fail(`Invalid lock list: ${parsedResult.error.message}`));
+    }
+    return ok(result);
+  }
+  sanitizeRef(path) {
+    return path.replace(/\\/g, "/").replace(/\/\//g, "/").replace(/^\//, "").replace(/\/$/, "").replace(/\//g, "_").replace(/\*\*/g, "--").replace(/[^a-zA-Z0-9_.-]/g, "_");
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createLockService(repoPath) {
+  return new LockService(repoPath);
+}
+
+// src/core/dashboard.service.ts
+var DashboardService = class {
+  constructor(root) {
+    this.root = root;
+    this.lockService = new LockService(root);
+  }
+  root;
+  lockService;
+  generate(configPath = ".oreshnik.portfolio.json") {
+    const configResult = this.loadPortfolio(configPath);
+    if (!configResult.ok) return configResult;
+    const config = configResult.value;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const projects = [];
+    let totalTasks = 0;
+    let totalDone = 0;
+    let totalPending = 0;
+    let projectsWithRepo = 0;
+    let projectsReady = 0;
+    let projectsBlocked = 0;
+    for (const project of config.projects) {
+      const dash = this.inspectProject(project);
+      projects.push(dash);
+      if (dash.repoExists) {
+        projectsWithRepo++;
+        if (dash.warnings.length === 0) projectsReady++;
+        else projectsBlocked++;
+      } else {
+        projectsBlocked++;
+      }
+      totalTasks += dash.taskCounts.total;
+      totalDone += dash.taskCounts.done;
+      totalPending += dash.taskCounts.total - dash.taskCounts.done;
+    }
+    return ok({
+      portfolioId: config.portfolio.id,
+      portfolioName: config.portfolio.name,
+      generatedAt: now,
+      projectCount: config.projects.length,
+      projectsWithRepo,
+      projectsReady,
+      projectsBlocked,
+      totalTasks,
+      totalDone,
+      totalPending,
+      projects
+    });
+  }
+  toMarkdown(dashboard) {
+    const lines = [
+      `# ${dashboard.portfolioName}`,
+      `Generated: ${dashboard.generatedAt}`,
+      ``,
+      `## Summary`,
+      ``,
+      `| Metric | Value |`,
+      `|---|---|`,
+      `| Projects | ${dashboard.projectCount} |`,
+      `| With repo | ${dashboard.projectsWithRepo} |`,
+      `| Ready | ${dashboard.projectsReady} |`,
+      `| Blocked | ${dashboard.projectsBlocked} |`,
+      `| Total tasks | ${dashboard.totalTasks} |`,
+      `| Done | ${dashboard.totalDone} |`,
+      `| Pending | ${dashboard.totalPending} |`,
+      ``,
+      `## Projects`,
+      ``
+    ];
+    for (const project of dashboard.projects) {
+      const status = project.repoExists ? project.warnings.length === 0 ? "ready" : "needs-attention" : "missing";
+      const icon = project.repoExists ? project.warnings.length === 0 ? "v" : "~" : "x";
+      lines.push(`### ${icon} ${project.displayName} (\`${project.projectId}\`) \u2014 ${status}`);
+      lines.push(``);
+      lines.push(`| Field | Value |`);
+      lines.push(`|---|---|`);
+      lines.push(`| Repo | ${project.repoExists ? project.repoPath : "not found"} |`);
+      lines.push(`| Task-board | ${project.taskBoardExists ? "found" : "missing"} |`);
+      lines.push(`| Zone-map | ${project.zoneMapExists ? "found" : "missing"} |`);
+      lines.push(`| Injection | ${project.injectionPolicy} |`);
+      lines.push(`| Priority | ${project.priority} |`);
+      lines.push(``);
+      if (project.repoExists) {
+        lines.push(`### Task Status`);
+        lines.push(``);
+        lines.push(`| Status | Count |`);
+        lines.push(`|---|---|`);
+        lines.push(`| Total | ${project.taskCounts.total} |`);
+        lines.push(`| Ready | ${project.taskCounts.ready} |`);
+        lines.push(`| Active | ${project.taskCounts.active} |`);
+        lines.push(`| Done | ${project.taskCounts.done} |`);
+        lines.push(`| Blocked | ${project.taskCounts.blocked} |`);
+        lines.push(`| Pending | ${project.taskCounts.pending} |`);
+        lines.push(``);
+        if (project.operatorBreakdown.length > 0) {
+          lines.push(`### Operator Breakdown`);
+          lines.push(``);
+          lines.push(`| Operator | Total | Ready | Active | Done | Blocked | Pending |`);
+          lines.push(`|---|---|---|---|---|---|---|`);
+          for (const ob of project.operatorBreakdown) {
+            lines.push(`| ${ob.operator} | ${ob.total} | ${ob.ready} | ${ob.active} | ${ob.done} | ${ob.blocked} | ${ob.pending} |`);
+          }
+          lines.push(``);
+        }
+        if (project.locks.length > 0) {
+          lines.push(`### Active Locks`);
+          lines.push(``);
+          lines.push(`| Zone | Operator | Sprint | Expires | Remaining |`);
+          lines.push(`|---|---|---|---|---|`);
+          for (const l of project.locks) {
+            lines.push(`| ${l.zone} | ${l.operator} | ${l.sprint} | ${l.expiresAt} | ${l.remainingMinutes}m |`);
+          }
+          lines.push(``);
+        }
+        if (project.lastUpdated) {
+          lines.push(`Last updated: ${project.lastUpdated}`);
+          lines.push(``);
+        }
+      }
+      for (const warning of project.warnings) {
+        lines.push(`- **Warning:** ${warning}`);
+      }
+      lines.push(``);
+    }
+    return lines.join("\n");
+  }
+  inspectProject(project) {
+    const repoPath = this.resolvePath(project.repoPath);
+    const repoExists = existsSync6(repoPath);
+    const taskBoardPath = join7(repoPath, ...project.taskBoardPath.split("/"));
+    const zoneMapPath = join7(repoPath, ...project.zoneMapPath.split("/"));
+    const taskBoardExists = repoExists && existsSync6(taskBoardPath);
+    const zoneMapExists = repoExists && existsSync6(zoneMapPath);
+    const warnings = [];
+    const taskCounts = {
+      total: 0,
+      ready: 0,
+      active: 0,
+      done: 0,
+      blocked: 0,
+      pending: 0
+    };
+    const operatorMap = /* @__PURE__ */ new Map();
+    const tasks = [];
+    let lastUpdated;
+    if (taskBoardExists) {
+      try {
+        const raw = JSON.parse(readFileSync6(taskBoardPath, "utf8").replace(/^\uFEFF/, ""));
+        const parsed = TaskBoardSchema.safeParse(raw);
+        if (parsed.success) {
+          const board = parsed.data;
+          taskCounts.total = board.tasks.length;
+          lastUpdated = board.updatedAt;
+          for (const task of board.tasks) {
+            if (task.status === "ready") taskCounts.ready++;
+            else if (task.status === "active") taskCounts.active++;
+            else if (task.status === "done") taskCounts.done++;
+            else if (task.status === "blocked") taskCounts.blocked++;
+            else taskCounts.pending++;
+            const owner = task.owner || "unassigned";
+            let ob = operatorMap.get(owner);
+            if (!ob) {
+              ob = { operator: owner, ready: 0, active: 0, done: 0, blocked: 0, pending: 0, total: 0 };
+              operatorMap.set(owner, ob);
+            }
+            ob.total++;
+            if (task.status === "ready") ob.ready++;
+            else if (task.status === "active") ob.active++;
+            else if (task.status === "done") ob.done++;
+            else if (task.status === "blocked") ob.blocked++;
+            else ob.pending++;
+            tasks.push({
+              id: task.id,
+              title: task.title.slice(0, 100),
+              owner: task.owner || "unassigned",
+              status: task.status,
+              dependsOn: task.dependsOn || []
+            });
+          }
+        } else {
+          warnings.push("task-board parse error");
+        }
+      } catch {
+        warnings.push("task-board read error");
+      }
+    }
+    const operatorBreakdown = Array.from(operatorMap.values()).sort((a, b) => b.total - a.total);
+    const locks = [];
+    try {
+      const lockResult = this.lockService.check();
+      if (lockResult.ok) {
+        for (const l of lockResult.value.active) {
+          const expiresAt = new Date(l.expiresAt);
+          const remainingMinutes = Math.max(0, Math.ceil((expiresAt.getTime() - Date.now()) / 6e4));
+          if (l.zone.includes(project.projectId) || l.zone.startsWith("**") || l.zone.startsWith("repo")) {
+            locks.push({
+              zone: l.zone,
+              operator: l.operator,
+              sprint: l.sprint,
+              expiresAt: l.expiresAt,
+              remainingMinutes
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    if (!repoExists) warnings.push("repo missing");
+    if (repoExists && !taskBoardExists) warnings.push("task-board missing");
+    if (repoExists && !zoneMapExists) warnings.push("zone-map missing");
+    if (project.validationGates.length === 0) warnings.push("validation gates missing");
+    return {
+      projectId: project.projectId,
+      displayName: project.displayName,
+      repoPath: project.repoPath,
+      repoExists,
+      taskBoardExists,
+      zoneMapExists,
+      injectionPolicy: project.injectionPolicy,
+      priority: project.priority,
+      taskCounts,
+      operatorBreakdown,
+      tasks,
+      locks,
+      lastUpdated,
+      warnings
+    };
+  }
+  loadPortfolio(configPath) {
+    const fullPath = this.resolvePath(configPath);
+    if (!existsSync6(fullPath)) {
+      return err(this.fail(`Portfolio config not found: ${configPath}`));
+    }
+    try {
+      const raw = JSON.parse(readFileSync6(fullPath, "utf8").replace(/^\uFEFF/, ""));
+      const parsed = PortfolioConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        return err(this.fail(`Invalid portfolio config: ${parsed.error.message}`));
+      }
+      return ok(parsed.data);
+    } catch (e) {
+      return err(this.fail(`Failed to read portfolio config: ${String(e)}`));
+    }
+  }
+  resolvePath(path) {
+    return isAbsolute5(path) ? path : resolve5(this.root, path);
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createDashboardService(root) {
+  return new DashboardService(root);
+}
+
+// src/core/zone-check.service.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { isAbsolute as isAbsolute6, join as join8, resolve as resolve6 } from "path";
+var ZoneCheckService = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  checkAll(configPath, operator, sprint, projectFilter) {
+    const configResult = this.loadPortfolio(configPath);
+    if (!configResult.ok) return configResult;
+    const config = configResult.value;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const targets = projectFilter ? config.projects.filter((p) => projectFilter.includes(p.projectId)) : config.projects;
+    const projects = [];
+    let projectsWithZoneMap = 0;
+    let projectsWithViolations = 0;
+    let projectsPassed = 0;
+    let totalViolations = 0;
+    let totalWarnings = 0;
+    for (const project of targets) {
+      const check = this.checkProject(project, operator, sprint);
+      projects.push(check);
+      if (check.zoneMapExists && check.zoneMapValid) {
+        projectsWithZoneMap++;
+        if (check.passed) projectsPassed++;
+        if (check.violations.length > 0) projectsWithViolations++;
+        totalViolations += check.violations.length;
+        totalWarnings += check.warnings.length;
+      }
+    }
+    return ok({
+      portfolioId: config.portfolio.id,
+      checkedAt: now,
+      operator,
+      sprint,
+      projects,
+      summary: {
+        totalProjects: projects.length,
+        projectsWithZoneMap,
+        projectsWithViolations,
+        projectsPassed,
+        totalViolations,
+        totalWarnings
+      }
+    });
+  }
+  checkProject(project, operator, sprint) {
+    const repoPath = this.resolvePath(project.repoPath);
+    const errors = [];
+    if (!existsSync7(repoPath)) {
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        repoPath: project.repoPath,
+        zoneMapExists: false,
+        zoneMapValid: false,
+        branch: "unknown",
+        filesChecked: 0,
+        violations: [],
+        warnings: [],
+        passed: false,
+        errors: ["repo not found"]
+      };
+    }
+    const zoneMapPath = join8(repoPath, ...project.zoneMapPath.split("/"));
+    const zoneMapExists = existsSync7(zoneMapPath);
+    if (!zoneMapExists) {
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        repoPath: project.repoPath,
+        zoneMapExists: false,
+        zoneMapValid: false,
+        branch: "unknown",
+        filesChecked: 0,
+        violations: [],
+        warnings: [],
+        passed: false,
+        errors: ["zone-map not found"]
+      };
+    }
+    let zoneMap;
+    try {
+      const raw = JSON.parse(readFileSync7(zoneMapPath, "utf8").replace(/^\uFEFF/, ""));
+      const parsed = ZoneMapSchema.safeParse(raw);
+      if (!parsed.success) {
+        return {
+          projectId: project.projectId,
+          displayName: project.displayName,
+          repoPath: project.repoPath,
+          zoneMapExists: true,
+          zoneMapValid: false,
+          branch: "unknown",
+          filesChecked: 0,
+          violations: [],
+          warnings: [],
+          passed: false,
+          errors: [`invalid zone-map: ${parsed.error.message}`]
+        };
+      }
+      zoneMap = parsed.data;
+    } catch (e) {
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        repoPath: project.repoPath,
+        zoneMapExists: true,
+        zoneMapValid: false,
+        branch: "unknown",
+        filesChecked: 0,
+        violations: [],
+        warnings: [],
+        passed: false,
+        errors: [`failed to read zone-map: ${String(e)}`]
+      };
+    }
+    const git = new GitService(repoPath);
+    const branchResult = git.currentBranch();
+    const branch = branchResult.ok ? branchResult.value : "unknown";
+    const statusResult = git.statusPorcelain();
+    if (!statusResult.ok) {
+      errors.push(`git status failed: ${statusResult.error.message}`);
+    }
+    const modifiedFiles = statusResult.ok ? statusResult.value.map((e) => e.path) : [];
+    const zoneEngine = createZoneEngine();
+    const checkResult = zoneEngine.check(
+      modifiedFiles,
+      operator,
+      sprint || "*",
+      zoneMap
+    );
+    return {
+      projectId: project.projectId,
+      displayName: project.displayName,
+      repoPath: project.repoPath,
+      zoneMapExists: true,
+      zoneMapValid: true,
+      branch,
+      filesChecked: checkResult.filesChecked,
+      violations: checkResult.violations,
+      warnings: checkResult.warnings,
+      passed: checkResult.violations.length === 0,
+      errors
+    };
+  }
+  loadPortfolio(configPath) {
+    const fullPath = this.resolvePath(configPath);
+    if (!existsSync7(fullPath)) {
+      return err(this.fail(`Portfolio config not found: ${configPath}`));
+    }
+    try {
+      const raw = JSON.parse(readFileSync7(fullPath, "utf8").replace(/^\uFEFF/, ""));
+      const parsed = PortfolioConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        return err(this.fail(`Invalid portfolio config: ${parsed.error.message}`));
+      }
+      return ok(parsed.data);
+    } catch (e) {
+      return err(this.fail(`Failed to read portfolio config: ${String(e)}`));
+    }
+  }
+  resolvePath(path) {
+    return isAbsolute6(path) ? path : resolve6(this.root, path);
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createZoneCheckService(root) {
+  return new ZoneCheckService(root);
+}
+
+// src/core/audit.service.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { isAbsolute as isAbsolute7, join as join9, resolve as resolve7 } from "path";
+var AuditService = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  audit(configPath = ".oreshnik.portfolio.json", projectFilter) {
+    const configResult = this.loadPortfolio(configPath);
+    if (!configResult.ok) return configResult;
+    const config = configResult.value;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const targets = projectFilter ? config.projects.filter((p) => projectFilter.includes(p.projectId)) : config.projects;
+    const projects = [];
+    let projectsWithRepo = 0;
+    let projectsDirty = 0;
+    let projectsClean = 0;
+    let totalTasks = 0;
+    let totalCheckpoints = 0;
+    for (const project of targets) {
+      const audit = this.auditProject(project);
+      projects.push(audit);
+      if (audit.repoExists) {
+        projectsWithRepo++;
+        if (audit.modifiedFiles > 0) projectsDirty++;
+        else projectsClean++;
+        totalTasks += audit.taskCount;
+        totalCheckpoints += audit.checkpointTags.length;
+      }
+    }
+    return ok({
+      portfolioId: config.portfolio.id,
+      auditedAt: now,
+      projects,
+      summary: {
+        totalProjects: projects.length,
+        projectsWithRepo,
+        projectsDirty,
+        projectsClean,
+        totalTasks,
+        totalCheckpoints
+      }
+    });
+  }
+  secretScan(configPath = ".oreshnik.portfolio.json") {
+    const configResult = this.loadPortfolio(configPath);
+    if (!configResult.ok) return configResult;
+    const config = configResult.value;
+    const findings = [];
+    const sensitivePatterns = [
+      { pattern: /\.env$/i, reason: "env file detected (should be in .gitignore)" },
+      { pattern: /credentials\.json$/i, reason: "credentials file detected" },
+      { pattern: /secret/i, reason: "file with 'secret' in name" },
+      { pattern: /\.pem$/i, reason: "private key file detected" }
+    ];
+    for (const project of config.projects) {
+      const repoPath = this.resolvePath(project.repoPath);
+      if (!existsSync8(repoPath)) continue;
+      try {
+        const git = new GitService(repoPath);
+        const statusResult = git.statusPorcelain();
+        if (!statusResult.ok) continue;
+        for (const entry of statusResult.value) {
+          for (const { pattern, reason } of sensitivePatterns) {
+            if (pattern.test(entry.path)) {
+              findings.push(`${project.projectId}: ${entry.path} \u2014 ${reason}`);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return ok(findings);
+  }
+  auditProject(project) {
+    const repoPath = this.resolvePath(project.repoPath);
+    const errors = [];
+    if (!existsSync8(repoPath)) {
+      return {
+        projectId: project.projectId,
+        displayName: project.displayName,
+        repoPath: project.repoPath,
+        repoExists: false,
+        branch: "unknown",
+        checkpointTags: [],
+        taskBoardExists: false,
+        taskCount: 0,
+        zoneMapExists: false,
+        zoneMapValid: false,
+        modifiedFiles: 0,
+        errors: ["repo not found"]
+      };
+    }
+    const git = new GitService(repoPath);
+    const branchResult = git.currentBranch();
+    const branch = branchResult.ok ? branchResult.value : "unknown";
+    let lastCommit;
+    try {
+      const logResult = git.exec(["log", "-1", "--format=%H|%s|%ai|%an"]);
+      if (logResult.ok && logResult.output) {
+        const parts = logResult.output.split("|");
+        const hash = parts[0];
+        if (hash) lastCommit = {
+          hash: hash.slice(0, 8),
+          message: parts[1] || "",
+          date: parts[2] || "",
+          author: parts[3] || ""
+        };
+      }
+    } catch {
+    }
+    const tagsResult = git.exec([
+      "tag",
+      "-l",
+      "oreshnik/*",
+      "--sort=-creatordate"
+    ]);
+    const checkpointTags = tagsResult.ok ? tagsResult.output.split("\n").filter(Boolean) : [];
+    const taskBoardPath = join9(repoPath, ...project.taskBoardPath.split("/"));
+    const taskBoardExists = existsSync8(taskBoardPath);
+    let taskCount = 0;
+    if (taskBoardExists) {
+      try {
+        const raw = JSON.parse(readFileSync8(taskBoardPath, "utf8").replace(/^\uFEFF/, ""));
+        taskCount = raw.tasks?.length || 0;
+      } catch {
+      }
+    }
+    const zoneMapPath = join9(repoPath, ...project.zoneMapPath.split("/"));
+    const zoneMapExists = existsSync8(zoneMapPath);
+    let zoneMapValid = false;
+    if (zoneMapExists) {
+      try {
+        const raw = JSON.parse(readFileSync8(zoneMapPath, "utf8").replace(/^\uFEFF/, ""));
+        zoneMapValid = raw.zones && Object.keys(raw.zones).length > 0;
+      } catch {
+      }
+    }
+    const statusResult = git.statusPorcelain();
+    const modifiedFiles = statusResult.ok ? statusResult.value.length : 0;
+    return {
+      projectId: project.projectId,
+      displayName: project.displayName,
+      repoPath: project.repoPath,
+      repoExists: true,
+      branch,
+      lastCommit,
+      checkpointTags,
+      taskBoardExists,
+      taskCount,
+      zoneMapExists,
+      zoneMapValid,
+      modifiedFiles,
+      errors
+    };
+  }
+  loadPortfolio(configPath) {
+    const fullPath = this.resolvePath(configPath);
+    if (!existsSync8(fullPath)) {
+      return err(this.fail(`Portfolio config not found: ${configPath}`));
+    }
+    try {
+      const raw = JSON.parse(readFileSync8(fullPath, "utf8").replace(/^\uFEFF/, ""));
+      const parsed = PortfolioConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        return err(this.fail(`Invalid portfolio config: ${parsed.error.message}`));
+      }
+      return ok(parsed.data);
+    } catch (e) {
+      return err(this.fail(`Failed to read portfolio config: ${String(e)}`));
+    }
+  }
+  resolvePath(path) {
+    return isAbsolute7(path) ? path : resolve7(this.root, path);
+  }
+  fail(message) {
+    return { code: "STATE_ERROR", message, exitCode: 1 };
+  }
+};
+function createAuditService(root) {
+  return new AuditService(root);
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+function log(level, message) {
+  const color = level === "OK" ? chalk.green : level === "FAIL" ? chalk.red : level === "WARN" ? chalk.yellow : chalk.cyan;
+  console.log(`  [ ${color(level.padEnd(4))} ] ${message}`);
+}
+function header(title, subtitle) {
+  console.log("");
+  console.log(chalk.bold("=".repeat(50)));
+  console.log(chalk.bold(`  ${title}`));
+  if (subtitle) console.log(chalk.bold(`  ${subtitle}`));
+  console.log(chalk.bold("=".repeat(50)));
+  console.log("");
+}
+function statusBox(lines) {
+  const maxKey = Math.max(...lines.map(([k]) => k.length));
+  console.log("");
+  console.log(chalk.bold("+" + "=".repeat(maxKey + 42) + "+"));
+  const title = "ORESHNIK STATUS";
+  const padLeft = Math.floor((maxKey + 42 - title.length) / 2);
+  console.log(chalk.bold("|" + " ".repeat(padLeft) + title + " ".repeat(maxKey + 42 - padLeft - title.length) + "|"));
+  console.log(chalk.bold("+" + "=".repeat(maxKey + 42) + "+"));
+  for (const [key, value] of lines) {
+    console.log(chalk.bold("|  ") + chalk.cyan(key.padEnd(maxKey)) + chalk.bold("  ") + value.padEnd(40) + chalk.bold("|"));
+  }
+  console.log(chalk.bold("+" + "=".repeat(maxKey + 42) + "+"));
+  console.log("");
+}
+function resultSummary(blockers, warnings, operator, sprint, branch, mother) {
+  console.log("");
+  console.log(chalk.bold("PRE-FLIGHT RESULT"));
+  console.log(`  Blockers:  ${blockers}`);
+  console.log(`  Warnings:  ${warnings}`);
+  console.log(`  Operator:  ${operator}`);
+  console.log(`  Sprint:    ${sprint || "not specified"}`);
+  console.log(`  Branch:    ${branch}`);
+  console.log(`  Mother:    ${mother}`);
+  console.log("");
+  if (blockers > 0) {
+    console.log(chalk.red.bold("[ORESHNIK] BLOCKED"));
+  } else {
+    console.log((warnings > 0 ? chalk.yellow : chalk.green).bold("[ORESHNIK] OK"));
+  }
+}
+
+// src/utils/exec.ts
+import { spawnSync as spawnSync3 } from "child_process";
+function execCommand(command, args, options) {
+  const result = spawnSync3(command, args, {
+    cwd: options?.cwd,
+    encoding: "utf8",
+    timeout: options?.timeout ?? 3e4,
+    stdio: "pipe",
+    shell: true
+  });
+  if (result.status !== 0) {
+    return err({
+      code: "GIT_ERROR",
+      message: `Command failed: ${command} ${args.join(" ")}`,
+      exitCode: result.status ?? 1,
+      gitCommand: `${command} ${args.join(" ")}`,
+      gitStderr: (result.stderr || "").trim()
+    });
+  }
+  return { ok: true, value: { output: (result.stdout || "").trim(), exitCode: result.status } };
+}
+function execCommandInherit(command, args, options) {
+  const result = spawnSync3(command, args, {
+    cwd: options?.cwd,
+    encoding: "utf8",
+    timeout: options?.timeout ?? 3e4,
+    stdio: "inherit",
+    shell: true
+  });
+  if (result.status !== 0) {
+    return err({
+      code: "GIT_ERROR",
+      message: `Command failed: ${command} ${args.join(" ")} (exit ${result.status})`,
+      exitCode: result.status ?? 1
+    });
+  }
+  return { ok: true, value: { exitCode: result.status ?? 0 } };
+}
+export {
+  AuditService,
+  BootstrapService,
+  CanonicalService,
+  DashboardService,
+  DerivedDocConfigSchema,
+  EvidenceGateResultSchema,
+  EvidenceGateService,
+  EvidenceRecordSchema,
+  GitService,
+  InjectionResultSchema,
+  InjectionService,
+  LockListSchema,
+  LockResultSchema,
+  LockService,
+  MotherVersionSchema,
+  NoteTaskSchema,
+  NotesIngestionResultSchema,
+  NotesIngestionService,
+  OperatorIdSchema,
+  OreshnikConfigSchema,
+  PortfolioConfigSchema,
+  PortfolioProjectSchema,
+  PortfolioService,
+  ProjectInjectionResultSchema,
+  SprintIdSchema,
+  StateManager,
+  SyncService,
+  TaskBoardSchema,
+  TaskEvidenceCheckSchema,
+  VaultGuard,
+  ZoneCheckService,
+  ZoneEngine,
+  ZoneLockSchema,
+  ZoneMapSchema,
+  createAuditService,
+  createBootstrapService,
+  createCanonicalService,
+  createDashboardService,
+  createEvidenceGateService,
+  createGitService,
+  createInjectionService,
+  createLockService,
+  createNotesIngestionService,
+  createPortfolioService,
+  createStateManager,
+  createSyncService,
+  createVaultGuard,
+  createZoneCheckService,
+  createZoneEngine,
+  err,
+  execCommand,
+  execCommandInherit,
+  formatBranchName,
+  header,
+  isChildBranch,
+  isMotherBranch,
+  log,
+  nonIgnoredDirtyFiles,
+  nowDisplay,
+  nowISO,
+  ok,
+  resultSummary,
+  sanitize,
+  statusBox,
+  today
+};
+//# sourceMappingURL=index.js.map