@treeseed/sdk 0.10.5 → 0.10.7

package/dist/operations/repository-operations.js

@@ -0,0 +1,634 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+import { serializeFrontmatterDocument, parseFrontmatterDocument } from "../frontmatter.js";
+const execFileAsync = promisify(execFile);
+const PLATFORM_CONTENT_COLLECTIONS = ["objectives", "questions", "notes", "proposals", "decisions", "agents"];
+const PLATFORM_WORK_CONTENT_COLLECTIONS = ["objectives", "questions", "notes", "proposals", "decisions"];
+const CONTENT_COLLECTION_SET = new Set(PLATFORM_CONTENT_COLLECTIONS);
+const WORK_CONTENT_COLLECTION_SET = new Set(PLATFORM_WORK_CONTENT_COLLECTIONS);
+const DECISION_TYPE_VALUES = ["approved", "rejected", "deferred", "request_changes", "superseded"];
+const PROPOSAL_VERDICT_DECISION_TYPES = /* @__PURE__ */ new Set(["approved", "rejected", "deferred", "request_changes"]);
+const CONTENT_DEFAULTS = {
+  objectives: {
+    idPrefix: "objective",
+    extension: "mdx",
+    fields: { timeHorizon: "near-term", motivation: "", primaryContributor: "market-steward", relatedQuestions: [], relatedBooks: [] },
+    body: "Describe the objective, expected outcome, and the evidence that should update it over time."
+  },
+  questions: {
+    idPrefix: "question",
+    extension: "mdx",
+    fields: { questionType: "strategy", motivation: "", primaryContributor: "market-steward", relatedObjectives: [], relatedBooks: [] },
+    body: "Describe what needs to be learned and what evidence would make the answer useful."
+  },
+  notes: {
+    idPrefix: "note",
+    extension: "mdx",
+    fields: { author: "market-steward", relatedObjectives: [], relatedQuestions: [], relatedProposals: [], relatedBooks: [] },
+    body: "Capture the useful context, evidence, and follow-up links for this note."
+  },
+  proposals: {
+    idPrefix: "proposal",
+    extension: "mdx",
+    fields: { proposalType: "implementation", motivation: "", primaryContributor: "market-steward", relatedObjectives: [], relatedQuestions: [], relatedNotes: [], relatedBooks: [], decision: "", supersedes: [] },
+    body: "Describe the proposed change, why it matters, what it affects, and how a reviewer should evaluate it."
+  },
+  decisions: {
+    idPrefix: "decision",
+    extension: "mdx",
+    fields: { decisionType: "approved", rationale: "", authority: "TreeSeed Market Team", primaryContributor: "market-steward", relatedObjectives: [], relatedQuestions: [], relatedNotes: [], relatedProposals: [], relatedBooks: [], supersedes: [], implements: [] },
+    body: "Record what was decided, why it was decided, and which proposals or evidence it closes."
+  },
+  agents: {
+    idPrefix: "agent",
+    extension: "mdx",
+    fields: {
+      name: "",
+      handler: "planner",
+      enabled: true,
+      operator: "TreeSeed platform",
+      runtimeStatus: "active",
+      capabilities: [],
+      tags: ["agent"],
+      systemPrompt: "Use the core objective as the first context message. Keep work observable, governed, and grounded in project content.",
+      persona: "Helpful, careful, and accountable.",
+      triggers: [{ type: "message", messageTypes: [] }],
+      permissions: [],
+      execution: { provider: "codex", model: "gpt-5.5", approvalPolicy: "never", sandboxMode: "read_only", reasoningEffort: "medium" },
+      outputs: {}
+    },
+    body: "Describe this agent role, operating boundaries, and expected outputs."
+  }
+};
+const CONTENT_RELATION_POLICIES = {
+  objectives: {
+    questions: { sourceField: "relatedQuestions", targetField: "relatedObjectives" }
+  },
+  questions: {
+    objectives: { sourceField: "relatedObjectives", targetField: "relatedQuestions" }
+  },
+  notes: {
+    objectives: { sourceField: "relatedObjectives" },
+    questions: { sourceField: "relatedQuestions" },
+    proposals: { sourceField: "relatedProposals", targetField: "relatedNotes" }
+  },
+  proposals: {
+    objectives: { sourceField: "relatedObjectives" },
+    questions: { sourceField: "relatedQuestions" },
+    notes: { sourceField: "relatedNotes", targetField: "relatedProposals" },
+    decisions: { sourceField: "decision", targetField: "relatedProposals", sourceSingle: true }
+  },
+  decisions: {
+    objectives: { sourceField: "relatedObjectives" },
+    questions: { sourceField: "relatedQuestions" },
+    notes: { sourceField: "relatedNotes" },
+    proposals: { sourceField: "relatedProposals", targetField: "decision", targetSingle: true }
+  }
+};
+class PlatformRepositoryVerificationError extends Error {
+  verification;
+  constructor(message, verification) {
+    super(message);
+    this.name = "PlatformRepositoryVerificationError";
+    this.verification = verification;
+  }
+}
+function optionalTrimmedString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function slugifyPlatformContent(value) {
+  return String(value ?? "").toLowerCase().trim().replace(/['"]/gu, "").replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 96);
+}
+function enumValue(value, allowed, fallback = null) {
+  const candidate = typeof value === "string" ? value.trim() : "";
+  return allowed.includes(candidate) ? candidate : fallback;
+}
+function normalizePlatformRelationArray(value) {
+  if (Array.isArray(value)) return value.map((entry) => String(entry).trim()).filter(Boolean);
+  if (typeof value === "string") return value.split(/[\n,]/u).map((entry) => entry.trim()).filter(Boolean);
+  return [];
+}
+function uniqueRelationArray(value) {
+  return [...new Set(normalizePlatformRelationArray(value))];
+}
+function addRelationValue(frontmatter, field, value, single = false) {
+  const ref = String(value ?? "").trim();
+  if (!field || !ref) return;
+  if (single) {
+    frontmatter[field] = ref;
+    return;
+  }
+  frontmatter[field] = uniqueRelationArray([...normalizePlatformRelationArray(frontmatter[field]), ref]);
+}
+function platformContentRelationPolicy(parentCollection, targetCollection) {
+  return CONTENT_RELATION_POLICIES[parentCollection]?.[targetCollection] ?? null;
+}
+function normalizePlatformContentInput(collection, body) {
+  const defaults = CONTENT_DEFAULTS[collection];
+  if (!defaults) return { error: "Unsupported content collection." };
+  const title = optionalTrimmedString(body.title);
+  if (!title) return { error: "title is required." };
+  const slug = slugifyPlatformContent(body.slug || title);
+  if (!slug) return { error: "A safe slug is required." };
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const summary = optionalTrimmedString(body.summary) ?? optionalTrimmedString(body.description) ?? title;
+  const description = optionalTrimmedString(body.description) ?? summary;
+  const frontmatter = {
+    id: optionalTrimmedString(body.id) ?? `${defaults.idPrefix}:${slug}`,
+    title,
+    description,
+    date: optionalTrimmedString(body.date) ?? today,
+    summary,
+    status: enumValue(body.status, ["recorded", "live", "in progress", "exploratory", "planned", "speculative"], "planned"),
+    ...defaults.fields
+  };
+  if (collection === "agents") {
+    frontmatter.name = optionalTrimmedString(body.name) ?? title;
+    frontmatter.slug = slug;
+    frontmatter.description = description;
+    frontmatter.summary = summary;
+    frontmatter.handler = optionalTrimmedString(body.handler) ?? frontmatter.handler;
+    frontmatter.systemPrompt = optionalTrimmedString(body.systemPrompt) ?? frontmatter.systemPrompt;
+    frontmatter.runtimeStatus = enumValue(body.runtimeStatus, ["active", "experimental", "dormant"], String(frontmatter.runtimeStatus));
+    delete frontmatter.date;
+    delete frontmatter.status;
+  } else if (collection === "notes") {
+    frontmatter.author = optionalTrimmedString(body.author) ?? frontmatter.author;
+    frontmatter.relatedObjectives = normalizePlatformRelationArray(body.relatedObjectives);
+    frontmatter.relatedQuestions = normalizePlatformRelationArray(body.relatedQuestions);
+    frontmatter.relatedProposals = normalizePlatformRelationArray(body.relatedProposals);
+  } else if (collection === "objectives") {
+    frontmatter.primaryContributor = optionalTrimmedString(body.primaryContributor) ?? frontmatter.primaryContributor;
+    frontmatter.timeHorizon = enumValue(body.timeHorizon, ["near-term", "mid-term", "long-term"], String(frontmatter.timeHorizon));
+    frontmatter.motivation = optionalTrimmedString(body.motivation) ?? description;
+    frontmatter.relatedQuestions = normalizePlatformRelationArray(body.relatedQuestions);
+  } else if (collection === "questions") {
+    frontmatter.primaryContributor = optionalTrimmedString(body.primaryContributor) ?? frontmatter.primaryContributor;
+    frontmatter.questionType = enumValue(body.questionType, ["research", "implementation", "strategy", "evaluation"], String(frontmatter.questionType));
+    frontmatter.motivation = optionalTrimmedString(body.motivation) ?? description;
+    frontmatter.relatedObjectives = normalizePlatformRelationArray(body.relatedObjectives);
+  } else if (collection === "proposals") {
+    frontmatter.primaryContributor = optionalTrimmedString(body.primaryContributor) ?? frontmatter.primaryContributor;
+    frontmatter.proposalType = enumValue(body.proposalType, ["strategy", "policy", "implementation", "research"], String(frontmatter.proposalType));
+    frontmatter.motivation = optionalTrimmedString(body.motivation) ?? description;
+    frontmatter.relatedObjectives = normalizePlatformRelationArray(body.relatedObjectives);
+    frontmatter.relatedQuestions = normalizePlatformRelationArray(body.relatedQuestions);
+    frontmatter.relatedNotes = normalizePlatformRelationArray(body.relatedNotes);
+    frontmatter.decision = optionalTrimmedString(body.decision) ?? void 0;
+  } else if (collection === "decisions") {
+    frontmatter.primaryContributor = optionalTrimmedString(body.primaryContributor) ?? frontmatter.primaryContributor;
+    frontmatter.decisionType = enumValue(body.decisionType, DECISION_TYPE_VALUES, String(frontmatter.decisionType));
+    frontmatter.rationale = optionalTrimmedString(body.rationale) ?? description;
+    frontmatter.authority = optionalTrimmedString(body.authority) ?? frontmatter.authority;
+    frontmatter.relatedObjectives = normalizePlatformRelationArray(body.relatedObjectives);
+    frontmatter.relatedQuestions = normalizePlatformRelationArray(body.relatedQuestions);
+    frontmatter.relatedNotes = normalizePlatformRelationArray(body.relatedNotes);
+    frontmatter.relatedProposals = normalizePlatformRelationArray(body.relatedProposals);
+  }
+  return {
+    slug,
+    extension: defaults.extension,
+    frontmatter: Object.fromEntries(Object.entries(frontmatter).filter(([, value]) => value !== void 0)),
+    body: optionalTrimmedString(body.body) ?? defaults.body
+  };
+}
+function derivePlatformRepositoryKey(repository) {
+  return [repository.provider ?? "git", repository.owner ?? "local", repository.name].join("-").toLowerCase().replace(/[^a-z0-9.-]+/gu, "-").replace(/^-+|-+$/gu, "") || "repository";
+}
+function resolvePlatformRepositoryWorkspacePath(workspaceRoot, repository) {
+  return resolve(workspaceRoot, "repositories", derivePlatformRepositoryKey(repository), "repo");
+}
+function createPlatformRepositoryClaim(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const leaseSeconds = Math.max(30, Math.min(Number(input.leaseSeconds ?? 300), 3600));
+  const repositoryKey = derivePlatformRepositoryKey(input.repository);
+  return {
+    id: `${repositoryKey}:${input.runnerId}`,
+    repositoryKey,
+    runnerId: input.runnerId,
+    workspacePath: resolvePlatformRepositoryWorkspacePath(input.workspaceRoot, input.repository),
+    branch: input.branch ?? input.repository.defaultBranch ?? null,
+    commitSha: input.commitSha ?? null,
+    claimState: "active",
+    leaseExpiresAt: new Date(Date.now() + leaseSeconds * 1e3).toISOString(),
+    metadata: input.metadata ?? {},
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function runGit(args, cwd) {
+  const result = await execFileAsync("git", args, {
+    cwd,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+    maxBuffer: 1024 * 1024 * 8
+  });
+  return `${result.stdout}${result.stderr}`.trim();
+}
+async function syncRepository(repository, workspaceRoot) {
+  const repoPath = resolvePlatformRepositoryWorkspacePath(workspaceRoot, repository);
+  const branch = repository.defaultBranch || "staging";
+  await mkdir(dirname(repoPath), { recursive: true });
+  if (!existsSync(resolve(repoPath, ".git"))) {
+    try {
+      await runGit(["clone", "--branch", branch, "--single-branch", repository.cloneUrl, repoPath], workspaceRoot);
+    } catch {
+      try {
+        await runGit(["clone", repository.cloneUrl, repoPath], workspaceRoot);
+        await runGit(["checkout", branch], repoPath).catch(() => "");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (repository.writeMode === "workspace" && message.includes("ENOENT")) {
+          await mkdir(repoPath, { recursive: true });
+        } else {
+          throw error;
+        }
+      }
+    }
+  } else {
+    await runGit(["fetch", "origin", branch, "--prune"], repoPath).catch(() => "");
+    await runGit(["checkout", branch], repoPath).catch(() => "");
+  }
+  return { repoPath, branch };
+}
+function contentRoot(repoPath, collection) {
+  if (!CONTENT_COLLECTION_SET.has(collection)) throw new Error("Unsupported content collection.");
+  return resolve(repoPath, "src", "content", collection);
+}
+function safeContentPath(repoPath, collection, slug, extension = null) {
+  const safeSlug = slugifyPlatformContent(slug);
+  if (!safeSlug || safeSlug !== String(slug ?? "").trim()) throw new Error("Unsafe content slug.");
+  const root = contentRoot(repoPath, collection);
+  const candidates = extension ? [resolve(root, `${safeSlug}.${extension}`)] : ["mdx", "md"].map((ext) => resolve(root, `${safeSlug}.${ext}`));
+  const target = candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+  const relativeTarget = relative(root, target);
+  if (relativeTarget.startsWith("..") || relativeTarget.includes("..") || relativeTarget.startsWith("/")) {
+    throw new Error("Unsafe content path.");
+  }
+  return target;
+}
+function assertAllowedPath(repoPath, targetPath) {
+  const relativePath = relative(repoPath, targetPath);
+  if (relativePath.startsWith("..") || relativePath.includes("..") || relativePath.startsWith("/")) {
+    throw new Error("Repository operation attempted to write outside the repository workspace.");
+  }
+  if (!relativePath.startsWith("src/content/")) {
+    throw new Error(`Repository operation path is outside src/content: ${relativePath}`);
+  }
+  return relativePath;
+}
+async function readContentRecord(repoPath, collection, slug) {
+  if (!WORK_CONTENT_COLLECTION_SET.has(collection)) throw new Error("Unsupported content collection.");
+  const target = safeContentPath(repoPath, collection, slug);
+  if (!existsSync(target)) throw new Error("Parent content record was not found.");
+  const parsed = parseFrontmatterDocument(await readFile(target, "utf8"));
+  if (!parsed.frontmatter || typeof parsed.frontmatter !== "object" || Array.isArray(parsed.frontmatter)) {
+    throw new Error("Content frontmatter could not be parsed.");
+  }
+  return {
+    path: target,
+    slug,
+    extension: target.endsWith(".md") ? "md" : "mdx",
+    frontmatter: parsed.frontmatter,
+    body: parsed.body
+  };
+}
+async function writeParsedRecord(repoPath, record) {
+  const relativePath = assertAllowedPath(repoPath, record.path);
+  await mkdir(dirname(record.path), { recursive: true });
+  await writeFile(record.path, serializeFrontmatterDocument(record.frontmatter, `
+${String(record.body ?? "").trim()}
+`), "utf8");
+  return relativePath;
+}
+async function writeContentRecord(repoPath, collection, input, normalizedInput) {
+  const normalized = normalizedInput ?? normalizePlatformContentInput(collection, input);
+  if ("error" in normalized) throw new Error(normalized.error);
+  const root = contentRoot(repoPath, collection);
+  const existingTarget = input.overwrite === true ? [`${normalized.slug}.mdx`, `${normalized.slug}.md`].map((file) => resolve(root, file)).find((candidate) => existsSync(candidate)) : null;
+  const target = existingTarget ?? safeContentPath(repoPath, collection, normalized.slug, normalized.extension);
+  if (existsSync(target) && input.overwrite !== true) throw new Error("A content record with that slug already exists.");
+  const relativePath = await writeParsedRecord(repoPath, {
+    path: target,
+    frontmatter: normalized.frontmatter,
+    body: normalized.body
+  });
+  return {
+    collection,
+    slug: normalized.slug,
+    id: normalized.frontmatter.id,
+    path: relativePath,
+    href: collection === "agents" ? `/app/projects/${encodeURIComponent(String(input.projectId ?? ""))}/agents/${encodeURIComponent(normalized.slug)}` : `/app/work/${collection}/${encodeURIComponent(normalized.slug)}`
+  };
+}
+async function createRelatedContent(repoPath, input) {
+  const parentCollection = String(input.parentCollection ?? "");
+  const targetCollection = String(input.targetCollection ?? input.collection ?? "");
+  if (!WORK_CONTENT_COLLECTION_SET.has(parentCollection) || !WORK_CONTENT_COLLECTION_SET.has(targetCollection)) {
+    throw new Error("Unsupported content relation collection.");
+  }
+  const policy = platformContentRelationPolicy(parentCollection, targetCollection);
+  if (!policy) throw new Error(`Cannot create related ${targetCollection} from ${parentCollection}.`);
+  const parentSlug = optionalTrimmedString(input.parentSlug);
+  if (!parentSlug) throw new Error("parentSlug is required.");
+  const parent = await readContentRecord(repoPath, parentCollection, parentSlug);
+  const normalized = input.normalized ?? normalizePlatformContentInput(targetCollection, input.payload ?? {});
+  if ("error" in normalized) throw new Error(normalized.error);
+  const childTarget = safeContentPath(repoPath, targetCollection, normalized.slug, normalized.extension);
+  if (existsSync(childTarget)) throw new Error("A content record with that slug already exists.");
+  addRelationValue(parent.frontmatter, policy.sourceField, normalized.slug, policy.sourceSingle);
+  addRelationValue(normalized.frontmatter, policy.targetField, parent.slug, policy.targetSingle);
+  await mkdir(contentRoot(repoPath, targetCollection), { recursive: true });
+  const child = {
+    path: childTarget,
+    frontmatter: normalized.frontmatter,
+    body: normalized.body
+  };
+  const originalParent = { ...parent, frontmatter: { ...parent.frontmatter }, body: parent.body };
+  const changedPaths2 = [];
+  try {
+    changedPaths2.push(await writeParsedRecord(repoPath, child));
+    changedPaths2.push(await writeParsedRecord(repoPath, parent));
+  } catch (error) {
+    await rm(childTarget, { force: true }).catch(() => {
+    });
+    await writeParsedRecord(repoPath, originalParent).catch(() => {
+    });
+    throw error;
+  }
+  return {
+    parent: {
+      collection: parentCollection,
+      slug: parent.slug,
+      path: relative(repoPath, parent.path),
+      href: `/app/work/${parentCollection}/${encodeURIComponent(parent.slug)}`
+    },
+    child: {
+      collection: targetCollection,
+      slug: normalized.slug,
+      id: normalized.frontmatter.id,
+      path: relative(repoPath, childTarget),
+      href: `/app/work/${targetCollection}/${encodeURIComponent(normalized.slug)}`
+    },
+    relation: {
+      parentField: policy.sourceField,
+      childField: policy.targetField
+    },
+    changedPaths: changedPaths2
+  };
+}
+async function createDecisionFromProposals(repoPath, input) {
+  const proposalSlugs = [...new Set(normalizePlatformRelationArray(input.proposalSlugs ?? input.payload?.proposalSlugs))];
+  if (proposalSlugs.length === 0) throw new Error("Select at least one proposal.");
+  for (const slug of proposalSlugs) {
+    if (!slug || slugifyPlatformContent(slug) !== slug) throw new Error("Unsafe proposal slug.");
+  }
+  const decisionType = enumValue(input.decisionType ?? input.payload?.decisionType, [...PROPOSAL_VERDICT_DECISION_TYPES], null);
+  if (!decisionType) throw new Error("Unsupported proposal verdict.");
+  const reason = optionalTrimmedString(input.reason) ?? optionalTrimmedString(input.payload?.reason) ?? optionalTrimmedString(input.payload?.rationale);
+  if (!reason) throw new Error("A decision reason is required.");
+  const title = optionalTrimmedString(input.title) ?? optionalTrimmedString(input.payload?.title) ?? `Decision for ${proposalSlugs.length === 1 ? proposalSlugs[0] : `${proposalSlugs.length} proposals`}`;
+  const decisionSlug = slugifyPlatformContent(input.slug || input.payload?.slug || title);
+  if (!decisionSlug) throw new Error("A safe decision slug is required.");
+  const decisionTarget = safeContentPath(repoPath, "decisions", decisionSlug, "mdx");
+  if (existsSync(decisionTarget)) throw new Error("A decision with that slug already exists.");
+  const proposals = [];
+  for (const slug of proposalSlugs) {
+    try {
+      proposals.push(await readContentRecord(repoPath, "proposals", slug));
+    } catch {
+      throw new Error(`Proposal ${slug} was not found.`);
+    }
+  }
+  const proposalTitles = proposals.map((proposal) => proposal.frontmatter.title ?? proposal.slug);
+  const body = optionalTrimmedString(input.payload?.body) ?? [
+    "## Verdict",
+    decisionType.replace(/_/gu, " "),
+    "",
+    "## Reason",
+    reason,
+    "",
+    "## Proposals",
+    ...proposalTitles.map((proposalTitle, index) => `- ${proposalTitle} (${proposalSlugs[index]})`)
+  ].join("\n");
+  const decision = await writeContentRecord(repoPath, "decisions", {
+    ...input.payload ?? {},
+    projectId: input.projectId,
+    slug: decisionSlug,
+    title,
+    status: "live",
+    decisionType,
+    description: optionalTrimmedString(input.payload?.description) ?? reason,
+    summary: optionalTrimmedString(input.payload?.summary) ?? reason,
+    rationale: reason,
+    relatedProposals: proposalSlugs,
+    body
+  });
+  const writtenProposals = [];
+  const originalProposals = proposals.map((proposal) => ({
+    ...proposal,
+    frontmatter: { ...proposal.frontmatter },
+    body: proposal.body
+  }));
+  const changedPaths2 = [decision.path];
+  try {
+    for (const proposal of proposals) {
+      proposal.frontmatter.decision = decisionSlug;
+      changedPaths2.push(await writeParsedRecord(repoPath, proposal));
+      writtenProposals.push(proposal);
+    }
+  } catch (error) {
+    await rm(decisionTarget, { force: true }).catch(() => {
+    });
+    for (const original of originalProposals.slice(0, writtenProposals.length)) {
+      await writeParsedRecord(repoPath, original).catch(() => {
+      });
+    }
+    throw error;
+  }
+  return {
+    decision,
+    proposals: proposalSlugs.map((slug) => ({ collection: "proposals", slug, href: `/app/work/proposals/${encodeURIComponent(slug)}` })),
+    href: decision.href,
+    changedPaths: changedPaths2
+  };
+}
+async function changedPaths(repoPath) {
+  const output = await runGit(["status", "--porcelain", "--untracked-files=all"], repoPath).catch(() => "");
+  return output.split("\n").map((line) => line.slice(3).trim()).filter(Boolean);
+}
+function changedPathsFromOutput(output) {
+  const paths = [];
+  if (typeof output.record === "object" && output.record && !Array.isArray(output.record) && typeof output.record.path === "string") {
+    paths.push(String(output.record.path));
+  }
+  if (Array.isArray(output.changedPaths)) {
+    paths.push(...output.changedPaths.map((entry) => String(entry)));
+  }
+  return [...new Set(paths.filter(Boolean))];
+}
+async function commitIfRequested(repoPath, repository, input, changed) {
+  if (repository.writeMode !== "branch") return { branch: null, commitSha: null };
+  const branchName = repository.branchName || `treeseed/platform-${Date.now()}`;
+  if (!/^[-/._a-zA-Z0-9]{1,120}$/u.test(branchName) || branchName.includes("..") || branchName.startsWith("/") || branchName.endsWith("/")) {
+    throw new Error("Repository branch name is outside the allowed platform operation policy.");
+  }
+  await runGit(["checkout", "-B", branchName], repoPath);
+  if (changed.length === 0) return { branch: branchName, commitSha: null };
+  await runGit(["add", "--", ...changed], repoPath);
+  await runGit([
+    "-c",
+    "user.name=TreeSeed Platform Runner",
+    "-c",
+    "user.email=platform-runner@treeseed.local",
+    "commit",
+    "-m",
+    input.commitMessage || `TreeSeed platform operation: ${input.projectId ?? "repository"}`
+  ], repoPath).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("nothing to commit")) throw error;
+  });
+  const commitSha = (await runGit(["rev-parse", "HEAD"], repoPath)).trim();
+  if (repository.push === true) {
+    await runGit(["push", "origin", branchName], repoPath);
+  }
+  return { branch: branchName, commitSha };
+}
+function commandOutput(value) {
+  return String(value ?? "").slice(0, 12e3);
+}
+async function runVerificationCommands(repoPath, repository) {
+  const commands = Array.isArray(repository.verificationCommands) ? repository.verificationCommands.filter((command) => command && typeof command.command === "string" && command.command.trim()) : [];
+  if (commands.length === 0) return null;
+  const results = [];
+  for (const command of commands) {
+    const args = Array.isArray(command.args) ? command.args.map(String) : [];
+    const cwd = resolve(repoPath, command.workingDirectory ?? ".");
+    const relativeCwd = relative(repoPath, cwd);
+    if (relativeCwd.startsWith("..") || relativeCwd.includes("..") || relativeCwd.startsWith("/")) {
+      throw new Error("Repository verification command attempted to run outside the repository workspace.");
+    }
+    try {
+      const result = await execFileAsync(command.command, args, {
+        cwd,
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+        timeout: Math.max(1e3, Math.min(Number(command.timeoutMs ?? 12e4), 6e5)),
+        maxBuffer: 1024 * 1024 * 8
+      });
+      results.push({
+        command: command.command,
+        args,
+        cwd: relative(repoPath, cwd) || ".",
+        exitCode: 0,
+        stdout: commandOutput(result.stdout),
+        stderr: commandOutput(result.stderr)
+      });
+    } catch (error) {
+      const failure = error;
+      results.push({
+        command: command.command,
+        args,
+        cwd: relative(repoPath, cwd) || ".",
+        exitCode: Number(failure.code ?? 1) || 1,
+        stdout: commandOutput(failure.stdout),
+        stderr: commandOutput(failure.stderr ?? failure.message)
+      });
+      const verification = { status: "failed", commands: results };
+      throw new PlatformRepositoryVerificationError(`Repository verification failed for "${command.command}".`, verification);
+    }
+  }
+  return { status: "passed", commands: results };
+}
+function assertRepositoryWriteMode(input, options) {
+  const mode = input.repository.writeMode ?? "workspace";
+  if (mode === "direct" || mode === "pull_request") {
+    throw new Error(`Repository write mode "${mode}" is not enabled for platform runner operations.`);
+  }
+  if (!["workspace", "branch"].includes(mode)) {
+    throw new Error(`Unsupported repository write mode "${mode}".`);
+  }
+  const environment = String(options.environment ?? "").toLowerCase();
+  const approvalGated = input.approvalRequired === true && Boolean(input.approvalId || input.payload?.approvalId);
+  if (input.repository.push === true && !approvalGated) {
+    throw new Error("Repository push requires an approval-gated platform operation.");
+  }
+  if ((environment === "prod" || environment === "production") && input.repository.push === true) {
+    throw new Error("Production repository push is disabled for this platform runner slice.");
+  }
+}
+function outputHref(output) {
+  if (typeof output.href === "string" && output.href.trim()) return output.href.trim();
+  for (const key of ["record", "child", "decision"]) {
+    const value = output[key];
+    if (value && typeof value === "object" && !Array.isArray(value) && typeof value.href === "string") {
+      return String(value.href).trim();
+    }
+  }
+  return null;
+}
+async function executePlatformRepositoryOperation(operation, input, options) {
+  if (!input.repository?.cloneUrl || !input.repository.name) {
+    throw new Error("Repository operation requires a repository descriptor with name and cloneUrl.");
+  }
+  assertRepositoryWriteMode(input, options);
+  const { repoPath, branch: baseBranch } = await syncRepository(input.repository, options.workspaceRoot);
+  let output;
+  if (operation === "write_content_record") {
+    const collection = String(input.collection ?? "");
+    const record = await writeContentRecord(repoPath, collection, {
+      ...input.payload ?? {},
+      projectId: input.projectId,
+      teamId: input.teamId,
+      createdBy: input.createdBy
+    }, input.normalized);
+    output = { record };
+  } else if (operation === "create_related_content") {
+    output = await createRelatedContent(repoPath, input);
+  } else if (operation === "create_decision_from_proposals") {
+    output = await createDecisionFromProposals(repoPath, input);
+  } else {
+    throw new Error(`Unsupported repository operation "${operation}".`);
+  }
+  const gitChanged = await changedPaths(repoPath);
+  const changed = gitChanged.length > 0 ? gitChanged : changedPathsFromOutput(output);
+  const verification = await runVerificationCommands(repoPath, input.repository);
+  const commit = await commitIfRequested(repoPath, input.repository, input, changed);
+  return {
+    ok: true,
+    operation,
+    repository: {
+      key: derivePlatformRepositoryKey(input.repository),
+      provider: input.repository.provider ?? "git",
+      owner: input.repository.owner ?? null,
+      name: input.repository.name,
+      cloneUrl: input.repository.cloneUrl
+    },
+    baseBranch,
+    repositoryPath: repoPath,
+    workspacePath: options.workspaceRoot,
+    href: outputHref(output),
+    branch: commit.branch ?? baseBranch,
+    operationBranch: commit.branch,
+    commitSha: commit.commitSha,
+    changedPaths: changed,
+    verification,
+    pullRequest: null,
+    workflowRun: null,
+    output
+  };
+}
+export {
+  PLATFORM_CONTENT_COLLECTIONS,
+  PLATFORM_WORK_CONTENT_COLLECTIONS,
+  PlatformRepositoryVerificationError,
+  createPlatformRepositoryClaim,
+  derivePlatformRepositoryKey,
+  executePlatformRepositoryOperation,
+  normalizePlatformContentInput,
+  normalizePlatformRelationArray,
+  platformContentRelationPolicy,
+  resolvePlatformRepositoryWorkspacePath,
+  slugifyPlatformContent
+};

package/dist/operations/services/config-runtime.d.ts

@@ -356,18 +356,19 @@ export declare function syncTreeseedRailwayEnvironment({ tenantRoot, scope, dryR
     dryRun?: boolean | undefined;
 }): {
     scope: string;
-    services: ({
-        service: string;
+    services: {
+        service: any;
+        instanceKey: any;
         projectName: any;
         serviceName: any;
         serviceId: any;
-        rootDir: string;
+        rootDir: any;
         baseUrl: any;
         environmentName: string;
-        secrets: string[];
-        variables: string[];
+        secrets: any;
+        variables: any;
         dryRun: boolean;
-    } | null)[];
+    }[];
 };
 export declare function initializeTreeseedPersistentEnvironment({ tenantRoot, scope, dryRun }?: {
     scope?: string | undefined;