@botbotgo/agent-harness 0.0.309 → 0.0.311

package/dist/scaffold/init-project.js

@@ -0,0 +1,651 @@
+import path from "node:path";
+import { writeFile } from "node:fs/promises";
+import { AGENT_HARNESS_VERSION } from "../package-version.js";
+import { readBundledText, renderBundledTemplate } from "../utils/bundled-text.js";
+import { ensureDir, fileExists } from "../utils/fs.js";
+function toProjectSlug(projectName) {
+    const normalized = projectName
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return normalized || "agent-harness-app";
+}
+function toDisplayName(projectName) {
+    return projectName
+        .trim()
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function resolveOptions(options = {}) {
+    return {
+        template: options.template ?? "deep-research",
+        provider: options.provider?.trim() || "openai",
+        model: options.model?.trim() || "gpt-4o-mini",
+        withWebSearch: options.withWebSearch ?? true,
+    };
+}
+function renderPackageJson(projectSlug, template) {
+    return `${JSON.stringify({
+        name: projectSlug,
+        version: "0.0.1",
+        private: true,
+        type: "module",
+        description: `Starter ${template} application generated by agent-harness init.`,
+        scripts: {
+            start: "node ./src/run.mjs",
+        },
+        dependencies: {
+            "@botbotgo/agent-harness": `^${AGENT_HARNESS_VERSION}`,
+        },
+    }, null, 2)}\n`;
+}
+function renderReadme(displayName, projectSlug, options) {
+    const webSearchLine = options.withWebSearch
+        ? `- ${options.provider} native web search enabled through \`config/catalogs/tools.yaml\``
+        : "- no provider-native web search by default";
+    const providerEnvLine = options.provider === "openai" ? "export OPENAI_API_KEY=your_key_here\n" : "";
+    const templateLine = options.template === "deep-research"
+        ? "- a host research agent plus an analyst subagent"
+        : "- a single host research agent for direct iteration";
+    return `# ${displayName}
+
+This project was scaffolded with \`agent-harness init ${projectSlug}\`.
+
+It is a minimal ${options.template} workspace with:
+
+${templateLine}
+${webSearchLine}
+- one host agent that already carries the default behavior skills for inspection, safe edits, approvals, and clean completion
+
+## Run
+
+\`\`\`bash
+npm install
+${providerEnvLine}npm run start -- "Research the latest model serving stack for agent products and summarize the tradeoffs."
+\`\`\`
+
+## Fast first prompts
+
+- \`Inspect this workspace and explain the main entry points.\`
+- \`Review this project structure before making any edits.\`
+- \`Update README.md to make the setup steps clearer.\`
+- \`Find the likeliest config issue in this workspace and propose the smallest fix.\`
+
+## Structure
+
+- \`src/run.mjs\`: minimal launcher
+- \`config/\`: workspace runtime and agent topology
+- \`config/knowledge/knowledge-runtime.yaml\`: optional standalone durable-knowledge policy mirror
+- \`config/knowledge/procedural-memory-runtime.yaml\`: optional background procedural-memory runtime backed by ReMe-compatible provider config
+- \`resources/\`: place local \`tool({...})\` tools and skills here as your product grows
+
+## Customize
+
+- change \`config/models.yaml\` to switch models or providers
+- keep \`config/runtime/runtime-memory.yaml\` for runtime-owned durable memory defaults
+- keep \`config/knowledge/knowledge-runtime.yaml\` when the same policy should also run in a standalone knowledge worker or server
+- keep \`config/knowledge/procedural-memory-runtime.yaml\` when background experience learning should stay separate from the durable knowledge store
+- add local \`tool({...})\` tools under \`resources/tools/\`
+- add product-specific skills under \`resources/skills/\`
+- edit the prompt files in \`config/prompts/\` to turn this into your own product
+`;
+}
+function renderGitignore() {
+    return `node_modules
+.agent
+`;
+}
+function renderWorkspaceYaml() {
+    return `apiVersion: agent-harness/v1alpha1
+kind: Runtime
+metadata:
+  name: default
+spec:
+  applicationRoot: .
+  dataRoot: ./.botbotgo
+  profile: default
+`;
+}
+function resolveResearchHostPromptTemplate(options) {
+    return options.template === "deep-research"
+        ? (options.withWebSearch
+            ? "init-templates/prompts/research-host-deep-research-web-search.md"
+            : "init-templates/prompts/research-host-deep-research-basic.md")
+        : (options.withWebSearch
+            ? "init-templates/prompts/research-host-single-agent-web-search.md"
+            : "init-templates/prompts/research-host-single-agent-basic.md");
+}
+function resolveResearchAnalystPromptTemplate(options) {
+    return options.withWebSearch
+        ? "init-templates/prompts/research-analyst-web-search.md"
+        : "init-templates/prompts/research-analyst-basic.md";
+}
+function renderAgentContext(options) {
+    return renderBundledTemplate("init-templates/agent-context/deep-research.md", {
+        webSearchGuidance: options.withWebSearch
+            ? "- Favor recent, attributable sources when the request depends on current information."
+            : "- Favor clear internal reasoning and add search or local tools as your product needs evolve.",
+    });
+}
+function renderModelsYaml(options) {
+    return `apiVersion: agent-harness/v1alpha1
+kind: Models
+spec:
+  - name: default
+    kind: Model
+    provider: ${options.provider}
+    model: ${options.model}
+    temperature: 0.2
+`;
+}
+function renderBackendsYaml() {
+    return `apiVersion: agent-harness/v1alpha1
+kind: Backends
+spec:
+  - kind: Backend
+    name: default
+    description: Default DeepAgent backend preset for generated research apps.
+    backendKind: CompositeBackend
+    state:
+      kind: VfsSandbox
+      timeout: 600
+    routes:
+      /memories/:
+        kind: StoreBackend
+`;
+}
+function renderRuntimeMemoryYaml(projectSlug) {
+    return `apiVersion: agent-harness/v1alpha1
+kind: RuntimeMemory
+metadata:
+  name: default
+spec:
+  enabled: true
+  store:
+    kind: SqliteStore
+    path: knowledge/knowledge.sqlite
+  namespaces:
+    users: memories/users/{userId}
+    projects: memories/projects/{projectId}
+    sessions: memories/sessions/{sessionId}
+    agents: memories/agents/{agentId}
+    workspaces: memories/workspaces/{workspaceId}
+  retrieval:
+    defaultTopK: 5
+    maxPromptMemories: 8
+  writePolicy:
+    mode: selective
+    allow:
+      - user_preferences
+      - project_facts
+      - confirmed_decisions
+      - reusable_summaries
+    deny:
+      - scratchpad
+      - transient_reasoning
+      - intermediate_results
+  ingestion:
+    backgroundConsolidation: true
+    writeOnApprovalResolution: false
+    writeOnRequestCompletion: false
+  formation:
+    hotPath:
+      enabled: true
+    manager:
+      enabled: true
+      strategy: model
+      prompt: |-
+        You are the runtime memory manager.
+        Decide whether a candidate should be stored as durable memory and refine it if appropriate.
+        Return JSON only.
+
+        Rules:
+        - Store only durable reusable knowledge. Reject transient chatter, scratchpad, or duplication without added value.
+        - Reject raw request/session summaries, source-specific page/news recaps, and generic "we learned how to use the tools/workflow" reflections unless they clearly contain reusable preferences, facts, decisions, or procedures.
+        - If transcript evidence shows the user explicitly asked the system to remember or follow a future instruction and the assistant confirmed that intent, store the durable instruction instead of rejecting it as a generic summary.
+        - Treat durable knowledge as generic mutable records with database-like operations over the same underlying knowledge item.
+        - One candidate may yield zero, one, or multiple durable knowledge items. Split it only when the input clearly contains multiple independently mutable knowledge points.
+        - When storing a knowledge item, always return a \`knowledgeMutation\` object with a stable \`identity\` and an \`operation\` of \`create\`, \`update\`, or \`delete\`.
+        - Keep \`knowledgeMutation.identity\` stable across revisions of the same knowledge point, even when the wording changes.
+        - Use \`create\` for a newly introduced knowledge item, \`update\` for a revised active state of an existing knowledge item, and \`delete\` when the candidate says an existing knowledge item should no longer remain active.
+        - If an existing relevant record already represents the same underlying knowledge item, reuse that record's \`knowledge_identity\` instead of inventing a new one.
+        - Do not invent a second identity just because the new statement negates, revokes, deletes, or replaces the old wording. That is usually the same knowledge item with a different mutation operation.
+        - The stored \`content\` must be canonical knowledge text, not an assistant acknowledgement such as "已记住" or "I will remember".
+        - You may optionally include \`operationalRule\` when the knowledge is naturally a rule, instruction, or recurring procedure. Treat it as structured metadata, not as the primary identity mechanism.
+        - Prefer semantic/episodic/procedural kinds only.
+        - Prefer scopes session/agent/workspace/user/project only.
+        - If the candidate should not be stored, return {"store": false, "reason": "..."}
+        - If the candidate maps to one durable item, you may return {"store": true, "content": "...", "summary": "...", "kind": "...", "scope": "...", "tags": ["..."], "confidence": 0.0, "knowledgeMutation": {"identity": "...", "operation": "create|update|delete"}, "operationalRule": {"trigger": "...", "action": "...", "target": "...", "effect": "apply|invalidate"}}
+        - If the candidate maps to multiple durable items, return {"store": true, "mutations": [{"content": "...", "summary": "...", "kind": "...", "scope": "...", "tags": ["..."], "confidence": 0.0, "knowledgeMutation": {"identity": "...", "operation": "create|update|delete"}, "operationalRule": {"trigger": "...", "action": "...", "target": "...", "effect": "apply|invalidate"}}]}
+
+        sessionId={{sessionId}}
+        requestId={{requestId}}
+
+        Candidate:
+        {{candidateJson}}
+
+        Existing relevant records:
+        {{existingRecords}}
+      maxContextRecords: 12
+    background:
+      enabled: true
+      scopes:
+        - user
+        - project
+        - workspace
+      stateStorePath: knowledge/formation-state.json
+      maxMessagesPerRequest: 40
+      writeOnApprovalResolution: true
+      writeOnRequestCompletion: true
+  sessionMemorySync:
+    enabled: false
+  mem0:
+    enabled: false
+    apiKeyEnv: MEM0_API_KEY
+    appId: ${projectSlug}
+    stateStorePath: knowledge/mem0-sync-state.json
+    maxMessagesPerRequest: 200
+`;
+}
+function renderKnowledgeRuntimeYaml(projectSlug) {
+    return `apiVersion: agent-harness/v1alpha1
+kind: KnowledgeRuntime
+metadata:
+  name: default
+spec:
+  enabled: true
+  store:
+    kind: SqliteStore
+    path: knowledge/knowledge.sqlite
+  namespaces:
+    users: memories/users/{userId}
+    projects: memories/projects/{projectId}
+    sessions: memories/sessions/{sessionId}
+    agents: memories/agents/{agentId}
+    workspaces: memories/workspaces/{workspaceId}
+  retrieval:
+    defaultTopK: 5
+    maxPromptMemories: 8
+  formation:
+    hotPath:
+      enabled: true
+    manager:
+      enabled: true
+      strategy: model
+      prompt: |-
+        You are the runtime memory manager.
+        Decide whether a candidate should be stored as durable memory and refine it if appropriate.
+        Return JSON only.
+
+        Rules:
+        - Store only durable reusable knowledge. Reject transient chatter, scratchpad, or duplication without added value.
+        - Reject raw request/session summaries, source-specific page/news recaps, and generic "we learned how to use the tools/workflow" reflections unless they clearly contain reusable preferences, facts, decisions, or procedures.
+        - If transcript evidence shows the user explicitly asked the system to remember or follow a future instruction and the assistant confirmed that intent, store the durable instruction instead of rejecting it as a generic summary.
+        - Treat durable knowledge as generic mutable records with database-like operations over the same underlying knowledge item.
+        - One candidate may yield zero, one, or multiple durable knowledge items. Split it only when the input clearly contains multiple independently mutable knowledge points.
+        - When storing a knowledge item, always return a \`knowledgeMutation\` object with a stable \`identity\` and an \`operation\` of \`create\`, \`update\`, or \`delete\`.
+        - Keep \`knowledgeMutation.identity\` stable across revisions of the same knowledge point, even when the wording changes.
+        - Use \`create\` for a newly introduced knowledge item, \`update\` for a revised active state of an existing knowledge item, and \`delete\` when the candidate says an existing knowledge item should no longer remain active.
+        - If an existing relevant record already represents the same underlying knowledge item, reuse that record's \`knowledge_identity\` instead of inventing a new one.
+        - Do not invent a second identity just because the new statement negates, revokes, deletes, or replaces the old wording. That is usually the same knowledge item with a different mutation operation.
+        - The stored \`content\` must be canonical knowledge text, not an assistant acknowledgement such as "已记住" or "I will remember".
+        - You may optionally include \`operationalRule\` when the knowledge is naturally a rule, instruction, or recurring procedure. Treat it as structured metadata, not as the primary identity mechanism.
+        - Prefer semantic/episodic/procedural kinds only.
+        - Prefer scopes session/agent/workspace/user/project only.
+        - If the candidate should not be stored, return {"store": false, "reason": "..."}
+        - If the candidate maps to one durable item, you may return {"store": true, "content": "...", "summary": "...", "kind": "...", "scope": "...", "tags": ["..."], "confidence": 0.0, "knowledgeMutation": {"identity": "...", "operation": "create|update|delete"}, "operationalRule": {"trigger": "...", "action": "...", "target": "...", "effect": "apply|invalidate"}}
+        - If the candidate maps to multiple durable items, return {"store": true, "mutations": [{"content": "...", "summary": "...", "kind": "...", "scope": "...", "tags": ["..."], "confidence": 0.0, "knowledgeMutation": {"identity": "...", "operation": "create|update|delete"}, "operationalRule": {"trigger": "...", "action": "...", "target": "...", "effect": "apply|invalidate"}}]}
+
+        sessionId={{sessionId}}
+        requestId={{requestId}}
+
+        Candidate:
+        {{candidateJson}}
+
+        Existing relevant records:
+        {{existingRecords}}
+      maxContextRecords: 12
+    background:
+      enabled: true
+      scopes:
+        - user
+        - project
+        - workspace
+      stateStorePath: knowledge/formation-state.json
+      maxMessagesPerRequest: 40
+      writeOnApprovalResolution: true
+      writeOnRequestCompletion: true
+  mem0:
+    enabled: false
+    apiKeyEnv: MEM0_API_KEY
+    appId: ${projectSlug}
+    stateStorePath: knowledge/mem0-sync-state.json
+    maxMessagesPerRequest: 200
+`;
+}
+function renderProceduralMemoryRuntimeYaml() {
+    return `apiVersion: agent-harness/v1alpha1
+kind: ProceduralMemoryRuntime
+metadata:
+  name: default
+spec:
+  enabled: true
+  provider:
+    kind: reme
+  mode:
+    backgroundOnly: true
+  trigger:
+    onRequestCompleted: true
+    onApprovalResolved: true
+  store:
+    kind: SqliteStore
+    path: knowledge/procedural-memory.sqlite
+  vectorStore:
+    kind: LibSQLVectorStore
+    url: file:knowledge/procedural-vectors.sqlite
+    table: procedural_memory
+    column: embedding
+  embeddingModel:
+    ref: embedding-model/default
+  extraction:
+    focus:
+      - coding_patterns
+      - debugging_lessons
+      - workflow_patterns
+      - failure_prevention
+      - reusable_procedures
+    maxMessagesPerRequest: 60
+  retrieval:
+    enabled: true
+    defaultTopK: 5
+    maxPromptItems: 4
+  state:
+    cursorPath: knowledge/procedural-memory-state.json
+  maintenance:
+    enabled: true
+    onWrite:
+      dedupeNearby: true
+      updateFrequency: true
+    schedule:
+      enabled: true
+      everyMinutes: 60
+    idle:
+      enabled: true
+      minIdleMinutes: 20
+      maxRunsPerIdleWindow: 1
+    tasks:
+      - dedupe
+      - merge_similar
+      - decay_stale
+      - prune_low_value
+    limits:
+      maxRecordsPerRun: 200
+      maxClustersPerRun: 50
+    decay:
+      enabled: true
+      maxAgeDays: 90
+    pruning:
+      minScore: 0.2
+      minFrequency: 2
+`;
+}
+function renderToolsYaml(options) {
+    if (!options.withWebSearch) {
+        return `apiVersion: agent-harness/v1alpha1
+kind: ToolSets
+spec: []
+`;
+    }
+    return `apiVersion: agent-harness/v1alpha1
+kind: ToolSets
+spec:
+  - name: web-search
+    type: provider
+    description: ${options.provider} web search tool for current research.
+    providerTool:
+      provider: ${options.provider}
+      tool: webSearch
+      args:
+        searchContextSize: medium
+`;
+}
+function renderResearchAgentYaml(options) {
+    const toolsBlock = options.withWebSearch ? "  tools:\n    - web-search\n" : "  tools: []\n";
+    const subagentsBlock = options.template === "deep-research" ? "  subagents:\n    - research-analyst\n" : "  subagents: []\n";
+    return `apiVersion: agent-harness/v1alpha1
+kind: Agent
+metadata:
+  name: research
+  description: Host-facing research agent for investigating and synthesizing answers.
+spec:
+  runtime:
+    runtimeMemory: default
+    proceduralMemory: default
+  backend: deepagent
+  modelRef: model/default
+${toolsBlock}  skills:
+    - workspace-inspection
+    - safe-editing
+    - delegation-discipline
+    - approval-execution-policy
+    - completion-discipline
+    - deep-research
+${subagentsBlock}  config:
+    backend: default
+  systemPrompt:
+    path: ../prompts/research-system.md
+`;
+}
+function renderResearchAnalystYaml(options) {
+    const toolsBlock = options.withWebSearch ? "  tools:\n    - web-search\n" : "  tools: []\n";
+    return `apiVersion: agent-harness/v1alpha1
+kind: Agent
+metadata:
+  name: research-analyst
+  description: Analyst subagent for source gathering, comparison, and evidence extraction.
+spec:
+  runtime:
+    runtimeMemory: default
+    proceduralMemory: default
+  backend: deepagent
+  modelRef: model/default
+${toolsBlock}  skills:
+    - workspace-inspection
+    - approval-execution-policy
+    - completion-discipline
+    - deep-research
+  config:
+    backend: default
+  systemPrompt:
+    path: ../prompts/research-analyst-system.md
+`;
+}
+function renderResourcePackageJson(projectSlug) {
+    return `${JSON.stringify({
+        name: `${projectSlug}-resources`,
+        version: "0.0.1",
+        private: true,
+        type: "module",
+        description: "Resource package for a generated agent-harness project.",
+    }, null, 2)}\n`;
+}
+function renderSkill(options) {
+    const stepTwo = options.withWebSearch
+        ? "2. Use `web-search` to collect recent primary or otherwise authoritative sources."
+        : "2. Collect the key facts and assumptions needed to answer the request cleanly.";
+    return `---
+name: deep-research
+description: Default research workflow for product investigations that need careful synthesis.
+---
+
+# Deep Research
+
+Use this skill when the user wants comparisons, source-backed analysis, or a concise brief.
+
+## Workflow
+
+1. Clarify the target question and what "done" looks like.
+${stepTwo}
+3. Compare evidence instead of trusting a single source.
+4. Separate verified facts from inference.
+5. End with a concise synthesis, explicit caveats, and source links when available.
+`;
+}
+function renderStarterSkill(name) {
+    if (name === "workspace-inspection") {
+        return `---
+name: workspace-inspection
+description: Inspect the current workspace before making claims or edits.
+---
+
+# Workspace Inspection
+
+1. Start with lightweight discovery such as \`list_files\` or \`search_files\`.
+2. Read only the files needed to establish the relevant facts.
+3. Ground each conclusion in inspected workspace evidence instead of guesses.
+4. If the workspace does not contain the needed evidence, say that plainly before proposing a next step.
+`;
+    }
+    if (name === "safe-editing") {
+        return `---
+name: safe-editing
+description: Make the smallest workspace change that solves the task, then verify it.
+---
+
+# Safe Editing
+
+1. Identify the exact file or files before editing.
+2. Prefer bounded edits over large rewrites.
+3. Keep local conventions intact.
+4. Run the smallest reasonable verification step before you finish.
+`;
+    }
+    if (name === "delegation-discipline") {
+        return `---
+name: delegation-discipline
+description: Delegate only when a subagent is clearly the best fit and the handoff can be bounded cleanly.
+---
+
+# Delegation Discipline
+
+1. Keep the next critical-path step local unless a subagent is clearly better.
+2. Delegate only with one bounded ask and a clear purpose.
+3. Integrate delegated results into one final answer instead of forwarding raw output.
+`;
+    }
+    if (name === "approval-execution-policy") {
+        return `---
+name: approval-execution-policy
+description: Treat side effects, command execution, and external actions as governed runtime decisions.
+---
+
+# Approval And Execution Policy
+
+1. Inspect first when the safest next step is still unclear.
+2. Request approval before destructive, external, privileged, or ambiguous actions.
+3. After approval, execute only the action that was approved and report the outcome plainly.
+`;
+    }
+    return `---
+name: completion-discipline
+description: Finish the task cleanly, verify what you can, and leave the user with a clear outcome.
+---
+
+# Completion Discipline
+
+1. Check whether the request is actually complete.
+2. Verify the changed or inspected area with the smallest relevant check.
+3. Distinguish completed work, unverified areas, and blocked follow-up.
+4. Return a concise final answer that makes the outcome easy to trust.
+`;
+}
+function renderRunScript(options) {
+    const defaultInput = options.withWebSearch
+        ? "Research the latest model and tooling trends for AI product teams. Return a concise brief with sources and caveats."
+        : "Analyze the current architecture direction for this product and return a concise brief with assumptions and caveats.";
+    return `import { fileURLToPath } from "node:url";
+import { createAgentHarness, request, stop } from "@botbotgo/agent-harness";
+
+const appRoot = fileURLToPath(new URL("..", import.meta.url));
+const args = process.argv.slice(2);
+let requestedAgentId = "research";
+const inputParts = [];
+
+for (let index = 0; index < args.length; index += 1) {
+  const arg = args[index];
+  if (arg === "--agent") {
+    const next = args[index + 1]?.trim();
+    if (next) {
+      requestedAgentId = next;
+      index += 1;
+      continue;
+    }
+    throw new Error("Missing value for --agent");
+  }
+  inputParts.push(arg);
+}
+
+const input = inputParts.join(" ").trim() ||
+  ${JSON.stringify(defaultInput)};
+
+const runtime = await createAgentHarness(appRoot);
+
+try {
+  const result = await request(runtime, {
+    agentId: requestedAgentId,
+    input,
+  });
+  process.stdout.write(\`\${result.output}\\n\`);
+} finally {
+  await stop(runtime);
+}
+`;
+}
+export async function initProject(projectRoot, projectName, options = {}) {
+    if (await fileExists(projectRoot)) {
+        throw new Error(`Target path already exists: ${projectRoot}`);
+    }
+    const resolved = resolveOptions(options);
+    const projectSlug = toProjectSlug(projectName);
+    const displayName = toDisplayName(projectName) || "Agent Harness App";
+    const files = new Map([
+        ["package.json", renderPackageJson(projectSlug, resolved.template)],
+        [".gitignore", renderGitignore()],
+        ["README.md", renderReadme(displayName, projectSlug, resolved)],
+        ["src/run.mjs", renderRunScript(resolved)],
+        ["config/runtime/workspace.yaml", renderWorkspaceYaml()],
+        ["config/agent-context.md", renderAgentContext(resolved)],
+        ["config/prompts/research-system.md", readBundledText(resolveResearchHostPromptTemplate(resolved)).trim()],
+        ["config/models.yaml", renderModelsYaml(resolved)],
+        ["config/knowledge/knowledge-runtime.yaml", renderKnowledgeRuntimeYaml(projectSlug)],
+        ["config/knowledge/procedural-memory-runtime.yaml", renderProceduralMemoryRuntimeYaml()],
+        ["config/runtime/runtime-memory.yaml", renderRuntimeMemoryYaml(projectSlug)],
+        ["config/catalogs/backends.yaml", renderBackendsYaml()],
+        ["config/catalogs/tools.yaml", renderToolsYaml(resolved)],
+        ["config/agents/research.yaml", renderResearchAgentYaml(resolved)],
+        ["resources/package.json", renderResourcePackageJson(projectSlug)],
+        ["resources/skills/deep-research/SKILL.md", renderSkill(resolved)],
+        ["resources/skills/workspace-inspection/SKILL.md", renderStarterSkill("workspace-inspection")],
+        ["resources/skills/safe-editing/SKILL.md", renderStarterSkill("safe-editing")],
+        ["resources/skills/delegation-discipline/SKILL.md", renderStarterSkill("delegation-discipline")],
+        ["resources/skills/approval-execution-policy/SKILL.md", renderStarterSkill("approval-execution-policy")],
+        ["resources/skills/completion-discipline/SKILL.md", renderStarterSkill("completion-discipline")],
+    ]);
+    if (resolved.template === "deep-research") {
+        files.set("config/prompts/research-analyst-system.md", readBundledText(resolveResearchAnalystPromptTemplate(resolved)).trim());
+        files.set("config/agents/research-analyst.yaml", renderResearchAnalystYaml(resolved));
+    }
+    await ensureDir(projectRoot);
+    for (const [relativePath, content] of files) {
+        const filePath = path.join(projectRoot, relativePath);
+        await ensureDir(path.dirname(filePath));
+        await writeFile(filePath, content, "utf8");
+    }
+    return {
+        projectRoot,
+        projectSlug,
+    };
+}

package/dist/{extensions.d.ts → tooling/extensions.d.ts}

@@ -1,4 +1,4 @@
-import type { CompiledTool, EventSubscriber, ParsedToolObject, PolicyEvaluator, SkillInheritancePolicy, SkillPackagingConvention, SkillSourceResolver, ToolKindAdapter } from "./contracts/types.js";
+import type { CompiledTool, EventSubscriber, ParsedToolObject, PolicyEvaluator, SkillInheritancePolicy, SkillPackagingConvention, SkillSourceResolver, ToolKindAdapter } from "../contracts/types.js";
 export declare function resolveToolTargets(tools: Map<string, ParsedToolObject>, ref: string): ParsedToolObject[];
 export declare function registerToolKind(adapter: ToolKindAdapter): void;
 export declare function getToolKindAdapter(type: string): ToolKindAdapter | undefined;

package/dist/{extensions.js → tooling/extensions.js}

@@ -1,7 +1,7 @@
 import path from "node:path";
-import { defaultResourceSkillsRoot } from "./resource/resource.js";
-import { isExternalSourceLocator, resolveExternalResourcePath } from "./resource/sources.js";
-import { hasAgentSystemPrompt } from "./workspace/support/agent-capabilities.js";
+import { defaultResourceSkillsRoot } from "../resource/resource.js";
+import { isExternalSourceLocator, resolveExternalResourcePath } from "../resource/sources.js";
+import { hasAgentSystemPrompt } from "../workspace/support/agent-capabilities.js";
 const toolKindAdapters = new Map();
 const skillSourceResolvers = new Map();
 const skillInheritancePolicies = new Map();

package/dist/{tool-modules.d.ts → tooling/module-loader.d.ts}

@@ -1,4 +1,4 @@
-import { normalizeToolSchema } from "./tools.js";
+import { normalizeToolSchema } from "../tools.js";
 type ImportedToolModule = Record<string, unknown>;
 export type LoadedToolModule = {
     implementationName: string;

package/dist/{tool-modules.js → tooling/module-loader.js}

@@ -1,6 +1,6 @@
 import path from "node:path";
-import { readSkillMetadata } from "./runtime/support/skill-metadata.js";
-import { TOOL_DEFINITION_MARKER, buildToolJsonSchema, normalizeToolSchema } from "./tools.js";
+import { readSkillMetadata } from "../runtime/skills/skill-metadata.js";
+import { TOOL_DEFINITION_MARKER, buildToolJsonSchema, normalizeToolSchema } from "../tools.js";
 const TOOL_MODULE_EXTENSIONS = new Set([".mjs", ".js", ".cjs"]);
 function isToolDefinitionObject(value) {
     return typeof value === "object" && value !== null && value[TOOL_DEFINITION_MARKER] === true;