@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/cli-tools.d.ts

@@ -1,3 +0,0 @@
-import type { AgentCliOptions } from './types/agents.js';
-export declare function normalizeAgentCliOptions(input: unknown): AgentCliOptions;
-export declare function buildCopilotAllowToolArgs(allowTools?: AgentCliOptions['allowTools']): string[];

package/dist/cli-tools.js

@@ -1,46 +0,0 @@
-const AGENT_CLI_ALLOW_TOOLS = [
-  "shell(git)",
-  "shell(npm)",
-  "web"
-];
-const ALLOWED_TOOL_SET = new Set(AGENT_CLI_ALLOW_TOOLS);
-function normalizeStringArray(value, field) {
-  if (value === void 0 || value === null) {
-    return [];
-  }
-  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
-    throw new Error(`Invalid agent cli.${field}: expected an array of strings.`);
-  }
-  return value.map(String);
-}
-function normalizeAgentCliOptions(input) {
-  if (input === void 0 || input === null) {
-    return {
-      allowTools: [],
-      additionalArgs: []
-    };
-  }
-  if (typeof input !== "object" || Array.isArray(input)) {
-    throw new Error("Invalid agent cli config: expected an object.");
-  }
-  const cli = input;
-  const rawAllowTools = normalizeStringArray(cli.allowTools, "allowTools");
-  const invalidTools = rawAllowTools.filter((tool) => !ALLOWED_TOOL_SET.has(tool));
-  if (invalidTools.length) {
-    throw new Error(
-      `Invalid agent cli.allowTools entries: ${invalidTools.join(", ")}. Allowed tools: ${AGENT_CLI_ALLOW_TOOLS.join(", ")}.`
-    );
-  }
-  return {
-    model: typeof cli.model === "string" ? cli.model : void 0,
-    allowTools: [...new Set(rawAllowTools)],
-    additionalArgs: normalizeStringArray(cli.additionalArgs, "additionalArgs")
-  };
-}
-function buildCopilotAllowToolArgs(allowTools = []) {
-  return (allowTools ?? []).flatMap((tool) => ["--allow-tool", tool]);
-}
-export {
-  buildCopilotAllowToolArgs,
-  normalizeAgentCliOptions
-};

package/dist/content-operations.d.ts

@@ -1,97 +0,0 @@
-import type { SdkModelRegistry } from './sdk-types.js';
-export type TreeseedContentAction = 'describe' | 'query' | 'read' | 'create' | 'update' | 'link' | 'validate' | 'commit';
-export type TreeseedContentModel = 'page' | 'note' | 'question' | 'proposal' | 'decision' | 'book' | 'knowledge' | 'objective' | 'person' | 'agent';
-export interface TreeseedContentRelationInput {
-    field: string;
-    targetModel?: TreeseedContentModel | string;
-    targetSlug: string;
-}
-export interface TreeseedContentPlacement {
-    bookSlug?: string;
-    parentPath?: string;
-    path?: string;
-}
-export interface TreeseedContentOperationInput {
-    action: TreeseedContentAction;
-    model?: TreeseedContentModel | string;
-    id?: string;
-    slug?: string;
-    title?: string;
-    fields?: Record<string, unknown>;
-    body?: string;
-    query?: string;
-    filters?: unknown[];
-    relations?: TreeseedContentRelationInput[];
-    placement?: TreeseedContentPlacement;
-    commit?: {
-        enabled: boolean;
-        message?: string;
-    };
-}
-export interface TreeseedContentRef {
-    model: TreeseedContentModel;
-    collection: string;
-    slug: string;
-    id?: string;
-    path?: string;
-    href?: string;
-}
-export interface TreeseedContentDiagnostic {
-    severity: 'info' | 'warning' | 'error';
-    code: string;
-    message: string;
-    field?: string;
-}
-export interface TreeseedContentOperationResult {
-    ok: true;
-    action: TreeseedContentAction;
-    refs: TreeseedContentRef[];
-    changedPaths?: string[];
-    diagnostics: TreeseedContentDiagnostic[];
-    payload?: Record<string, unknown>;
-}
-export interface RenderTreeseedContentInput {
-    model: TreeseedContentModel | string;
-    slug?: string;
-    title?: string;
-    fields?: Record<string, unknown>;
-    body?: string;
-    relations?: TreeseedContentRelationInput[];
-    placement?: TreeseedContentPlacement;
-    existingFrontmatter?: Record<string, unknown>;
-    registry?: SdkModelRegistry;
-    now?: string;
-}
-export interface RenderedTreeseedContentRecord {
-    model: TreeseedContentModel;
-    collection: string;
-    slug: string;
-    path: string;
-    frontmatter: Record<string, unknown>;
-    body: string;
-    content: string;
-    ref: TreeseedContentRef;
-    diagnostics: TreeseedContentDiagnostic[];
-}
-export interface TreeseedContentToolPreset {
-    id: string;
-    action: TreeseedContentAction;
-    model?: TreeseedContentModel;
-    title: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-}
-export declare const TREESEED_CONTENT_ACTIONS: TreeseedContentAction[];
-export declare const TREESEED_CONTENT_READ_ACTIONS: Set<TreeseedContentAction>;
-export declare const TREESEED_CONTENT_WRITE_ACTIONS: Set<TreeseedContentAction>;
-export declare function slugifyTreeseedContent(value: unknown): string;
-export declare function renderTreeseedContentRecord(input: RenderTreeseedContentInput): RenderedTreeseedContentRecord;
-export declare function validateTreeseedContentRecord(model: string, source: string, registry?: SdkModelRegistry): {
-    ok: boolean;
-    frontmatter: Record<string, unknown>;
-    body: string;
-    diagnostics: TreeseedContentDiagnostic[];
-};
-export declare function genericTreeseedContentInputSchema(action: TreeseedContentAction): Record<string, unknown>;
-export declare function createTreeseedContentToolPresets(registry?: SdkModelRegistry): TreeseedContentToolPreset[];
-export declare function findTreeseedContentToolPreset(id: string, registry?: SdkModelRegistry): TreeseedContentToolPreset | null;

package/dist/content-operations.js

@@ -1,250 +0,0 @@
-import { serializeFrontmatterDocument, parseFrontmatterDocument } from "./frontmatter.js";
-import { buildBuiltinModelRegistry, resolveModelDefinition } from "./model-registry.js";
-import { canonicalizeFrontmatter, normalizeMutationData } from "./sdk-fields.js";
-const CONTENT_MODELS = /* @__PURE__ */ new Set([
-  "page",
-  "note",
-  "question",
-  "proposal",
-  "decision",
-  "book",
-  "knowledge",
-  "objective",
-  "person",
-  "agent"
-]);
-const TREESEED_CONTENT_ACTIONS = [
-  "describe",
-  "query",
-  "read",
-  "create",
-  "update",
-  "link",
-  "validate",
-  "commit"
-];
-const TREESEED_CONTENT_READ_ACTIONS = /* @__PURE__ */ new Set(["describe", "query", "read"]);
-const TREESEED_CONTENT_WRITE_ACTIONS = /* @__PURE__ */ new Set(["create", "update", "link", "validate"]);
-function slugifyTreeseedContent(value) {
-  return String(value ?? "").toLowerCase().trim().replace(/['"]/gu, "").replace(/[^a-z0-9/_-]+/gu, "-").replace(/\/+/gu, "/").replace(/^-+|-+$/gu, "").slice(0, 160);
-}
-function titleCase(value) {
-  return value.replace(/_/gu, " ").replace(/\b\w/gu, (letter) => letter.toUpperCase());
-}
-function collectionFor(definition) {
-  return definition.contentCollection ?? `${definition.name}s`;
-}
-function toolNamespaceFor(definition) {
-  if (definition.name === "knowledge") return "knowledge";
-  return collectionFor(definition);
-}
-function extensionFor(model) {
-  return model === "knowledge" ? "md" : "mdx";
-}
-function contentPathFor(definition, slug, placement) {
-  const collection = collectionFor(definition);
-  const ext = extensionFor(definition.name);
-  if (placement?.path) {
-    const safePath = slugifyTreeseedContent(placement.path).replace(/\.(md|mdx)$/iu, "");
-    if (!safePath) throw new Error("placement.path must resolve to a safe content path.");
-    return `src/content/${collection}/${safePath}.${ext}`;
-  }
-  if (definition.name === "knowledge" && placement?.parentPath) {
-    const parent = slugifyTreeseedContent(placement.parentPath).replace(/\/$/u, "");
-    return `src/content/${collection}/${parent ? `${parent}/` : ""}${slug}.${ext}`;
-  }
-  return `src/content/${collection}/${slug}.${ext}`;
-}
-function normalizeContentModel(model, registry = buildBuiltinModelRegistry()) {
-  const definition = resolveModelDefinition(model, registry);
-  if (definition.storage !== "content" || !definition.contentCollection) {
-    throw new Error(`Model "${model}" is not a content-backed TreeSeed model.`);
-  }
-  if (!CONTENT_MODELS.has(definition.name)) {
-    throw new Error(`Model "${model}" is not supported by TreeSeed content tools.`);
-  }
-  return definition;
-}
-function defaultTitleField(definition) {
-  if (definition.fields.title) return "title";
-  if (definition.fields.name) return "name";
-  return "title";
-}
-function frontmatterId(definition, slug) {
-  return `${definition.name}:${slug}`;
-}
-function renderTreeseedContentRecord(input) {
-  const definition = normalizeContentModel(String(input.model), input.registry);
-  const rawTitle = input.title ?? input.fields?.title ?? input.fields?.name;
-  const slug = slugifyTreeseedContent(input.slug ?? rawTitle ?? input.id);
-  if (!slug) throw new Error("A title or safe slug is required.");
-  const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
-  const titleField = defaultTitleField(definition);
-  const rawFields = {
-    ...rawTitle ? { [titleField]: rawTitle } : {},
-    ...input.fields ?? {},
-    ...definition.fields.slug ? { slug } : {},
-    ...definition.fields.updated_at ? { updated_at: input.fields?.updated_at ?? input.fields?.updatedAt ?? now } : {}
-  };
-  const modelFieldNames = /* @__PURE__ */ new Set([
-    ...Object.keys(definition.fields),
-    ...Object.values(definition.fields).flatMap((binding) => [
-      ...binding.aliases ?? [],
-      ...binding.contentKeys ?? []
-    ])
-  ]);
-  const fields = normalizeMutationData(
-    definition,
-    Object.fromEntries(Object.entries(rawFields).filter(([key]) => modelFieldNames.has(key)))
-  );
-  const frontmatter = canonicalizeFrontmatter(definition, input.existingFrontmatter ?? {}, fields);
-  frontmatter.id = input.id ?? (typeof frontmatter.id === "string" && frontmatter.id.trim() ? frontmatter.id : frontmatterId(definition, slug));
-  if (!frontmatter.slug && definition.fields.slug) frontmatter.slug = slug;
-  for (const relation of input.relations ?? []) {
-    if (!relation.field || !relation.targetSlug) continue;
-    const key = relation.field;
-    const current = frontmatter[key];
-    const next = Array.isArray(current) ? current.map(String) : typeof current === "string" && current ? [current] : [];
-    frontmatter[key] = [.../* @__PURE__ */ new Set([...next, relation.targetSlug])];
-  }
-  const body = String(input.body ?? "").trim();
-  const collection = collectionFor(definition);
-  const recordPath = contentPathFor(definition, slug, input.placement);
-  const ref = {
-    model: definition.name,
-    collection,
-    slug,
-    id: typeof frontmatter.id === "string" ? frontmatter.id : void 0,
-    path: recordPath,
-    href: `/app/work/${collection}/${encodeURIComponent(slug)}`
-  };
-  return {
-    model: definition.name,
-    collection,
-    slug,
-    path: recordPath,
-    frontmatter,
-    body,
-    content: serializeFrontmatterDocument(frontmatter, body ? `
-${body}
-` : "\n"),
-    ref,
-    diagnostics: []
-  };
-}
-function validateTreeseedContentRecord(model, source, registry = buildBuiltinModelRegistry()) {
-  const definition = normalizeContentModel(model, registry);
-  const parsed = parseFrontmatterDocument(source);
-  const diagnostics = [];
-  if (!parsed.frontmatter || typeof parsed.frontmatter !== "object" || Array.isArray(parsed.frontmatter)) {
-    diagnostics.push({ severity: "error", code: "frontmatter_missing", message: "Content frontmatter must be an object." });
-  }
-  const titleField = defaultTitleField(definition);
-  const titleKeys = [titleField, ...definition.fields[titleField]?.contentKeys ?? []];
-  if (!titleKeys.some((key) => typeof parsed.frontmatter[key] === "string" && String(parsed.frontmatter[key]).trim())) {
-    diagnostics.push({ severity: "error", code: "title_missing", field: titleField, message: `${titleCase(titleField)} is required.` });
-  }
-  return {
-    ok: diagnostics.every((entry) => entry.severity !== "error"),
-    frontmatter: parsed.frontmatter,
-    body: parsed.body,
-    diagnostics
-  };
-}
-const GENERIC_MODEL_SCHEMA = { type: "string" };
-const STRING_ARRAY_SCHEMA = { type: "array", items: { type: "string" } };
-function genericTreeseedContentInputSchema(action) {
-  const properties = {
-    model: GENERIC_MODEL_SCHEMA,
-    id: { type: "string" },
-    slug: { type: "string" },
-    title: { type: "string" },
-    fields: { type: "object", additionalProperties: true },
-    body: { type: "string" },
-    query: { type: "string" },
-    filters: { type: "array", items: { type: "object", additionalProperties: true } },
-    relations: { type: "array", items: { type: "object", additionalProperties: true } },
-    placement: { type: "object", additionalProperties: true },
-    message: { type: "string" }
-  };
-  const required = action === "commit" ? ["message"] : action === "query" ? ["model"] : action === "describe" ? [] : ["model"];
-  return {
-    type: "object",
-    properties,
-    required,
-    additionalProperties: false
-  };
-}
-function presetSchema(action, model) {
-  const base = genericTreeseedContentInputSchema(action);
-  const properties = { ...base.properties };
-  delete properties.model;
-  if (action === "query") {
-    return { ...base, properties, required: [] };
-  }
-  if (action === "read") {
-    return { ...base, properties, required: [] };
-  }
-  if (action === "commit") {
-    return { ...base, properties: { message: { type: "string" } }, required: ["message"] };
-  }
-  const required = model === "person" || model === "agent" ? [] : ["title"];
-  return {
-    ...base,
-    properties: {
-      ...properties,
-      tags: STRING_ARRAY_SCHEMA
-    },
-    required
-  };
-}
-function createTreeseedContentToolPresets(registry = buildBuiltinModelRegistry()) {
-  const presets = [];
-  for (const definition of Object.values(registry)) {
-    if (definition.storage !== "content" || !definition.contentCollection || !CONTENT_MODELS.has(definition.name)) continue;
-    const model = definition.name;
-    const plural = toolNamespaceFor(definition);
-    for (const action of ["query", "read", "create", "update"]) {
-      if (!definition.operations.includes(action === "query" ? "search" : action)) continue;
-      presets.push({
-        id: `treeseed.${plural}.${action}`,
-        action,
-        model,
-        title: `${titleCase(plural)} ${action}`,
-        description: `${titleCase(action)} ${plural} through the TreeSeed model-aware content runtime.`,
-        inputSchema: presetSchema(action, model)
-      });
-    }
-  }
-  presets.push({
-    id: "treeseed.books.add_knowledge",
-    action: "create",
-    model: "knowledge",
-    title: "Add knowledge to book",
-    description: "Create a knowledge page in a book or knowledge directory tree through TreeSeed content validation.",
-    inputSchema: presetSchema("create", "knowledge")
-  });
-  presets.push({
-    id: "treeseed.content.link_note",
-    action: "link",
-    model: "note",
-    title: "Link note",
-    description: "Attach a note to another TreeSeed content record using validated relation fields.",
-    inputSchema: genericTreeseedContentInputSchema("link")
-  });
-  return presets;
-}
-function findTreeseedContentToolPreset(id, registry) {
-  return createTreeseedContentToolPresets(registry).find((preset) => preset.id === id) ?? null;
-}
-export {
-  TREESEED_CONTENT_ACTIONS,
-  TREESEED_CONTENT_READ_ACTIONS,
-  TREESEED_CONTENT_WRITE_ACTIONS,
-  createTreeseedContentToolPresets,
-  findTreeseedContentToolPreset,
-  genericTreeseedContentInputSchema,
-  renderTreeseedContentRecord,
-  slugifyTreeseedContent,
-  validateTreeseedContentRecord
-};

package/dist/content-store.d.ts

@@ -1,25 +0,0 @@
-import type { SdkContentEntry, SdkFollowRequest, SdkGetRequest, SdkModelRegistry, SdkMutationRequest, SdkPickRequest, SdkPickResult, SdkSearchRequest, SdkUpdateRequest } from './sdk-types.js';
-import type { AgentDatabase } from './d1-store.js';
-export declare class ContentStore {
-    private readonly repoRoot;
-    private readonly database;
-    private readonly models;
-    private readonly gitRuntime;
-    constructor(repoRoot: string, database: AgentDatabase, models: SdkModelRegistry);
-    list(model: string): Promise<SdkContentEntry[]>;
-    get(request: SdkGetRequest): Promise<SdkContentEntry | null>;
-    search(request: SdkSearchRequest): Promise<SdkContentEntry[]>;
-    follow(request: SdkFollowRequest): Promise<{
-        items: SdkContentEntry[];
-        since: string;
-    }>;
-    pick(request: SdkPickRequest): Promise<SdkPickResult<SdkContentEntry>>;
-    create(request: SdkMutationRequest): Promise<{
-        item: SdkContentEntry;
-        git: import("./git-runtime.js").GitMutationResult;
-    }>;
-    update(request: SdkUpdateRequest): Promise<{
-        item: SdkContentEntry;
-        git: import("./git-runtime.js").GitMutationResult;
-    }>;
-}

package/dist/content-store.js

@@ -1,269 +0,0 @@
-import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-import crypto from "node:crypto";
-import { parseFrontmatterDocument, serializeFrontmatterDocument } from "./frontmatter.js";
-import { resolveModelDefinition } from "./model-registry.js";
-import { applyFilters, applySort } from "./sdk-filters.js";
-import { canonicalizeFrontmatter, normalizeFilterFields, normalizeMutationData, normalizeRecordToCanonicalShape, normalizeSortFields, readCanonicalFieldValue } from "./sdk-fields.js";
-import { assertExpectedVersion } from "./sdk-version.js";
-import { GitRuntime } from "./git-runtime.js";
-function pickSortForStrategy(definition, request) {
-  switch (request.strategy) {
-    case "oldest":
-      return [{ field: definition.pickField, direction: "asc" }];
-    case "highest_priority":
-      if (definition.sortableFields.includes("priority") || definition.filterableFields.includes("priority")) {
-        return [
-          { field: "priority", direction: "desc" },
-          { field: definition.pickField, direction: "desc" }
-        ];
-      }
-      return [{ field: definition.pickField, direction: "desc" }];
-    case "latest":
-    default:
-      return [{ field: definition.pickField, direction: "desc" }];
-  }
-}
-async function walkMarkdownFiles(root) {
-  try {
-    const entries = await readdir(root, { withFileTypes: true });
-    const files = await Promise.all(
-      entries.map(async (entry) => {
-        const fullPath = path.join(root, entry.name);
-        if (entry.isDirectory()) {
-          return walkMarkdownFiles(fullPath);
-        }
-        if (entry.isFile() && /\.(md|mdx)$/i.test(entry.name)) {
-          return [fullPath];
-        }
-        return [];
-      })
-    );
-    return files.flat();
-  } catch {
-    return [];
-  }
-}
-async function findWorktreeRoots(root) {
-  const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
-  const names = new Set(entries.map((entry) => entry.name));
-  const nested = await Promise.all(
-    entries.filter((entry) => entry.isDirectory()).map((entry) => findWorktreeRoots(path.join(root, entry.name)))
-  );
-  return [
-    ...names.has(".git") ? [root] : [],
-    ...nested.flat()
-  ];
-}
-function inferSlug(filePath, root) {
-  const relativePath = path.relative(root, filePath).replace(/\\/g, "/");
-  return relativePath.replace(/\.(md|mdx)$/i, "");
-}
-async function readContentEntry(definition, filePath, contentDir) {
-  const source = await readFile(filePath, "utf8");
-  const parsed = parseFrontmatterDocument(source);
-  const fileStats = await stat(filePath);
-  const slug = inferSlug(filePath, contentDir);
-  const titleField = definition.fields.title ? readCanonicalFieldValue(definition, { frontmatter: parsed.frontmatter }, "title") : void 0;
-  const createdField = definition.fields.created_at ? readCanonicalFieldValue(definition, { frontmatter: parsed.frontmatter }, "created_at") : void 0;
-  const updatedField = definition.fields.updated_at ? readCanonicalFieldValue(definition, { frontmatter: parsed.frontmatter }, "updated_at") : void 0;
-  const nameField = definition.fields.name ? readCanonicalFieldValue(definition, { frontmatter: parsed.frontmatter }, "name") : void 0;
-  return {
-    id: slug,
-    slug,
-    model: definition.name,
-    title: typeof titleField === "string" ? String(titleField) : typeof nameField === "string" ? String(nameField) : void 0,
-    path: filePath,
-    body: parsed.body,
-    frontmatter: parsed.frontmatter,
-    createdAt: typeof createdField === "string" ? String(createdField) : fileStats.birthtime.toISOString(),
-    updatedAt: typeof updatedField === "string" ? String(updatedField) : fileStats.mtime.toISOString()
-  };
-}
-function entryMatchesIdentity(entry, request) {
-  return [request.id, request.slug, request.key].filter(Boolean).includes(entry.id);
-}
-function ensureMutationAllowed(definition, operation) {
-  if (!definition.operations.includes(operation)) {
-    throw new Error(`Model "${definition.name}" does not allow ${operation}.`);
-  }
-}
-function sanitizeFrontmatterInput(data) {
-  const next = { ...data };
-  delete next.body;
-  delete next.branchPrefix;
-  return next;
-}
-class ContentStore {
-  constructor(repoRoot, database, models) {
-    this.repoRoot = repoRoot;
-    this.database = database;
-    this.models = models;
-    this.gitRuntime = new GitRuntime(
-      repoRoot,
-      process.env.TREESEED_AGENT_DISABLE_GIT === "true"
-    );
-  }
-  repoRoot;
-  database;
-  models;
-  gitRuntime;
-  async list(model) {
-    const definition = resolveModelDefinition(model, this.models);
-    if (definition.storage !== "content" || !definition.contentDir) {
-      throw new Error(`Model "${model}" is not content-backed.`);
-    }
-    const roots = [
-      {
-        contentDir: definition.contentDir
-      }
-    ];
-    const worktreeRoot = path.join(this.repoRoot, ".agent-worktrees");
-    const worktrees = await findWorktreeRoots(worktreeRoot);
-    const relativeContentDir = path.relative(this.repoRoot, definition.contentDir);
-    for (const worktree of worktrees) {
-      roots.push({
-        contentDir: path.join(worktree, relativeContentDir)
-      });
-    }
-    const files = (await Promise.all(roots.map((root) => walkMarkdownFiles(root.contentDir)))).flat();
-    const entries = await Promise.all(
-      files.map(async (filePath) => {
-        const matchingRoot = roots.find((root) => filePath.startsWith(root.contentDir));
-        return readContentEntry(definition, filePath, matchingRoot?.contentDir ?? definition.contentDir);
-      })
-    );
-    const deduped = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
-      const existing = deduped.get(entry.id);
-      if (!existing || new Date(entry.updatedAt ?? 0).valueOf() >= new Date(existing.updatedAt ?? 0).valueOf()) {
-        deduped.set(entry.id, entry);
-      }
-    }
-    return [...deduped.values()];
-  }
-  async get(request) {
-    const entries = await this.list(request.model);
-    return entries.find((entry) => entryMatchesIdentity(entry, request)) ?? null;
-  }
-  async search(request) {
-    const definition = resolveModelDefinition(request.model, this.models);
-    const items = await this.list(request.model);
-    const filtered = applyFilters(items, normalizeFilterFields(definition, request.filters), definition);
-    const sorted = applySort(filtered, normalizeSortFields(definition, request.sort), definition);
-    return sorted.slice(0, request.limit ?? sorted.length);
-  }
-  async follow(request) {
-    const items = await this.search({
-      model: request.model,
-      filters: [
-        ...request.filters ?? [],
-        {
-          field: "updatedAt",
-          op: "updated_since",
-          value: request.since
-        }
-      ]
-    });
-    return {
-      items,
-      since: request.since
-    };
-  }
-  async pick(request) {
-    const definition = resolveModelDefinition(request.model, this.models);
-    const sorted = await this.search({
-      model: request.model,
-      filters: request.filters,
-      sort: pickSortForStrategy(definition, request),
-      limit: 25
-    });
-    for (const item of sorted) {
-      const lease = await this.database.tryClaimContentLease({
-        model: definition.name,
-        itemKey: item.id,
-        claimedBy: request.workerId,
-        leaseSeconds: request.leaseSeconds
-      });
-      if (lease) {
-        return {
-          item,
-          leaseToken: lease
-        };
-      }
-    }
-    return {
-      item: null,
-      leaseToken: null
-    };
-  }
-  async create(request) {
-    const definition = resolveModelDefinition(request.model, this.models);
-    ensureMutationAllowed(definition, "create");
-    if (!definition.contentDir) {
-      throw new Error(`Model "${request.model}" is not content-backed.`);
-    }
-    const slug = String(request.data.slug ?? request.data.id ?? crypto.randomUUID());
-    const extension = definition.name === "knowledge" ? ".md" : ".mdx";
-    const body = typeof request.data.body === "string" ? request.data.body : "";
-    const branchName = `${String(request.data.branchPrefix ?? "agent")}/${definition.name}-${slug}`;
-    const worktreePath = await this.gitRuntime.ensureWorktree(branchName);
-    const contentDirInWorktree = path.join(worktreePath, path.relative(this.repoRoot, definition.contentDir));
-    const relativePath = path.relative(this.repoRoot, path.join(definition.contentDir, `${slug}${extension}`));
-    const filePath = path.join(worktreePath, relativePath);
-    const mutationData = normalizeMutationData(definition, sanitizeFrontmatterInput(request.data));
-    const frontmatter = canonicalizeFrontmatter(definition, {}, {
-      ...mutationData,
-      slug,
-      updated_at: mutationData.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
-    });
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, serializeFrontmatterDocument(frontmatter, body), "utf8");
-    const git = await this.gitRuntime.commitFileChange(
-      filePath,
-      branchName,
-      `agent(${definition.name}): create ${slug}`
-    );
-    return {
-      item: await readContentEntry(definition, filePath, contentDirInWorktree),
-      git
-    };
-  }
-  async update(request) {
-    const definition = resolveModelDefinition(request.model, this.models);
-    ensureMutationAllowed(definition, "update");
-    const existing = await this.get(request);
-    if (!existing) {
-      throw new Error(`No ${request.model} entry found for update.`);
-    }
-    assertExpectedVersion(request.expectedVersion, existing, `${definition.name} "${existing.slug}"`);
-    const branchName = `${String(request.data.branchPrefix ?? "agent")}/${definition.name}-${existing.slug}`;
-    const worktreePath = await this.gitRuntime.ensureWorktree(branchName);
-    const relativePath = path.relative(this.repoRoot, existing.path);
-    const targetPath = path.join(worktreePath, relativePath);
-    const mutationData = normalizeMutationData(definition, sanitizeFrontmatterInput(request.data));
-    const nextFrontmatter = canonicalizeFrontmatter(
-      definition,
-      normalizeRecordToCanonicalShape(definition, existing.frontmatter),
-      {
-        ...mutationData,
-        updated_at: mutationData.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
-      }
-    );
-    const nextBody = typeof request.data.body === "string" ? request.data.body : existing.body;
-    await mkdir(path.dirname(targetPath), { recursive: true });
-    await writeFile(targetPath, serializeFrontmatterDocument(nextFrontmatter, nextBody), "utf8");
-    const git = await this.gitRuntime.commitFileChange(
-      targetPath,
-      branchName,
-      `agent(${definition.name}): update ${existing.slug}`
-    );
-    return {
-      item: await readContentEntry(definition, targetPath, path.join(worktreePath, path.relative(this.repoRoot, definition.contentDir))),
-      git
-    };
-  }
-}
-export {
-  ContentStore
-};