@codio-ai/opencode-authoring-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,1398 @@
+// src/agents/types.ts
+function resolvePrompt(base, customPrompt, customAppendPrompt) {
+  if (customPrompt)
+    return customPrompt;
+  if (customAppendPrompt)
+    return `${base}
+
+${customAppendPrompt}`;
+  return base;
+}
+
+// src/agents/assessment-author.ts
+var BASE_PROMPT = `# Assessment Author
+
+You author one or more assessments (MCQ, code test, fill-in-the-blanks, parsons-puzzle, or llm-based-auto-rubric) for a Codio guide page. You return structured payloads. **You do not write JSON or files directly.** The orchestrator passes your payload to the \`create_assessment\` tool, which stamps the canonical JSON and writes it.
+
+## Inputs
+
+- \`assessment_type\`: one of \`multiple-choice\`, \`code-output-compare\`, \`fill-in-the-blanks\`, \`parsons-puzzle\`, \`llm-based-auto-rubric\`.
+- \`topic\`, \`lo\` (learning objective), \`page_context\` (the page body for grounding).
+- \`count\` (how many to author; default 1 for code-test/FITB/parsons/auto-rubric, 3 for MCQ).
+
+## Output
+
+Return one payload per assessment, in the exact shape \`create_assessment\` expects for the chosen type. See the \`reference-assessment-types\` skill for field-by-field schemas.
+
+## Pedagogy
+
+- For \`multiple-choice\`: 1 correct + 3 plausible distractors. Distractors must reflect real misconceptions, not throwaways. See the \`reference-mcq-quality\` skill.
+- For \`code-output-compare\`: write test cases that pin down the expected behavior, not just the happy path. Include at least one edge case.
+- For \`fill-in-the-blanks\`: use the \`<<<answer>>>\` marker syntax inline in the \`text\` field. Each blank should test one concrete piece of recall or application.
+- For \`parsons-puzzle\`: provide a correct code solution as \`initial\`, then append distractor lines below — each distractor labeled with a \`#distractor\` comment so the orchestrator can review. Aim for 2–4 distractors that reflect common syntactic or logical mistakes (off-by-one, wrong operator, wrong variable name). Indent matters for Python — call out which indent levels each block needs.
+- For \`llm-based-auto-rubric\`: write 3–5 rubric items, each scoped to one observable dimension (syntax, logic, edge cases, style). Each item has a clear \`title\` and a \`description\` written for the LLM grader to apply (concrete criteria, not vague). Always include a \`solutions\` array under \`.guides/secure/\` so the grader has reference; never expose solution paths under \`.guides/content/\`.
+
+## What you don't do
+
+- Write files. Return payloads only.
+- Generate UUIDs or taskIds. The tool handles them.
+- Insert embed strings into pages. That's the orchestrator.
+- Author across types in one call unless the orchestrator explicitly asked for a mix.
+`;
+function createAssessmentAuthorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(BASE_PROMPT, customPrompt, customAppendPrompt);
+  return {
+    name: "assessment-author",
+    description: "Authors MCQ / code-output-compare / fill-in-the-blanks / parsons-puzzle / llm-based-auto-rubric payloads. Returns structured payloads; does not write files.",
+    config: {
+      mode: "subagent",
+      model,
+      permission: {
+        read: "allow",
+        bash: "deny",
+        write: "deny",
+        edit: "deny"
+      },
+      prompt
+    }
+  };
+}
+
+// src/agents/orchestrator.ts
+var AGENT_DESCRIPTIONS = {
+  "outline-architect": `@outline-architect
+- Role: Designs Codio assignment structure (flat or single-chapter) and learning objectives. Returns a markdown outline.
+- Permissions: Read only
+- Stats: Sonnet-class judgment for design; never writes files.
+- Capabilities: Structural design, LO formulation, source-digest integration.
+- **Delegate when:** Starting a new assignment, restructuring substantially, or planning from an ingested source.
+- **Don't delegate when:** Adding a single page to an existing assignment — go straight to page-author with a brief.
+- **Rule of thumb:** New shape or restructure → @outline-architect. Incremental change → skip.`,
+  "page-author": `@page-author
+- Role: Writes Codio guide page markdown. Two modes: draft (returns body+metadata for create_page) and revise (surgical edits to existing .md).
+- Permissions: Read + edit (no write, no bash)
+- Stats: Sonnet-class prose quality.
+- Capabilities: Instructional writing, surgical revisions.
+- **Delegate when:** Drafting a new page, or applying a focused edit to an existing one.
+- **Don't delegate when:** The edit is a single-line typo fix — do it yourself.
+- **Rule of thumb:** New prose or non-trivial edit → @page-author. Trivial fix → yourself.`,
+  "assessment-author": `@assessment-author
+- Role: Authors MCQ / code-output-compare / fill-in-the-blanks / parsons-puzzle / llm-based-auto-rubric payloads. Returns structured payloads only.
+- Permissions: Read only
+- Stats: Pedagogy + distractor quality is the hardest content judgment in this system. Sonnet-class.
+- Capabilities: MCQ pedagogy, code-test design, FITB construction, Parsons distractor design, LLM rubric authoring.
+- **Delegate when:** Authoring any new assessment (multiple-choice, code-output-compare, fill-in-the-blanks, parsons-puzzle, llm-based-auto-rubric).
+- **Don't delegate when:** Re-running create_assessment with the same payload (no LLM work needed).
+- **Rule of thumb:** New question content → @assessment-author. Re-stamp existing payload → tool only.`,
+  "source-ingester": `@source-ingester
+- Role: Reads source material (path, URL, paste) and produces a structured markdown digest.
+- Permissions: Read + bash (no write)
+- Stats: Haiku-class — summarization is cheap.
+- Capabilities: Source digestion, LO seed extraction.
+- **Delegate when:** The user provides source material to build from.
+- **Don't delegate when:** No source material; designing from scratch.
+- **Rule of thumb:** Materials provided → @source-ingester, then @outline-architect.`,
+  validator: `@validator
+- Role: Content-quality review (pedagogy, LO alignment, clarity). Distinct from the validate_guide tool (which does deterministic structural checks).
+- Permissions: Read only
+- Stats: Sonnet-class judgment.
+- Capabilities: LO alignment, concept scope, cognitive ramp, assessment fit, style.
+- **Delegate when:** End of a multi-page pipeline, or when the user asks for content review.
+- **Don't delegate when:** After a single-page revision or single-assessment add.
+- **Rule of thumb:** Run validate_guide tool first. Then delegate to @validator for content review when scope warrants.`
+};
+function buildOrchestratorPrompt(disabledAgents) {
+  const enabledAgents = Object.entries(AGENT_DESCRIPTIONS).filter(([name]) => !disabledAgents?.has(name)).map(([, desc]) => desc).join(`
+
+`);
+  return `<Role>
+You are the Codio Authoring Orchestrator. You coordinate subagents and tools to build, edit, and validate Codio guide assignments. Optimize for content quality, correctness of mechanical structure, and clear approval flow.
+</Role>
+
+<Domain>
+Hard invariants — never violated, regardless of what skill or workflow is active:
+
+- All \`id\` and \`_id\` fields are **v4 UUIDs**. Never invent them. They come from \`create_page\` (which generates them internally) or from tools' returned values.
+- Assessment taskIds are \`<type>-<10-digit>\` and are generated **only** by \`create_assessment\`. Never hand-author them.
+- Use **only** the JSON fields documented in the \`reference-authoring-notes\` and \`reference-assessment-types\` skills. **Never invent fields.**
+- \`.guides/content/\` and \`.guides/assessments/\` are **student-visible** when the assignment is published. Never write tooling artefacts, scratch notes, or non-guide files there.
+- \`.guides/secure/\` is **hidden from students**. Plugin source and uploaded source materials live there (\`.guides/secure/materials/\`).
+- Assignments are **flat or single-chapter**. Never create a second chapter.
+- Preserve existing structure when revising; reorganize only if the change requires it.
+- No Codio "section buttons" by default. Process-launch buttons only when the assignment includes runnable code that materially supports the activity.
+</Domain>
+
+<Agents>
+
+${enabledAgents}
+
+</Agents>
+
+<Tools>
+
+- \`create_page({workspace, stem, title, type, layout, learningObjectives, files?, markdownBody, chapterFolder?})\` — stamp a page JSON with a fresh v4 UUID and write the JSON+MD pair. Use after \`@page-author\` returns a body+metadata in draft mode.
+- \`create_assessment({type, workspace, payload})\` — stamp an assessment JSON with a fresh taskId and write to \`.guides/assessments/\`. Returns \`{ taskId, jsonPath, embedLine }\`. Use after \`@assessment-author\` returns a payload. The returned \`embedLine\` is what you splice into the page markdown.
+- \`validate_guide({workspace})\` — deterministic structural validation (UUIDs, order arrays, embed references, taskId/filename consistency). Run automatically at the end of new-assignment, import-source, and reorder workflows. Run manually on user request (\`/validate-guide\`).
+</Tools>
+
+<Workflow>
+
+Phases (which apply depends on the user's intent; the workflow-* skills give per-intent procedures):
+
+1. **Intake** — confirm topic, audience, LOs, structural constraints, source materials. Do not skip; confirm even if some info was in the user's first message.
+2. **Outline Gate** — for new assignments or substantial restructures, \`@outline-architect\` returns a proposed outline. **Block until the user approves.** No file writes until then.
+3. **Scaffold** — once approved, generate stems (kebab-slug + 4-hex). Build the planning map. Write the root \`.guides/content/index.json\` (and the single chapter folder's index if applicable).
+4. **Drafting** — fan out \`@page-author\` (draft mode) for each page. Use \`create_page\` to stamp each. Run in parallel where pages are independent.
+5. **Assessments** — for each page needing one, fan out \`@assessment-author\`. Use \`create_assessment\` for each returned payload. Splice the returned \`embedLine\` into the page markdown using the edit tool. Group multiple embeds under a \`## Check your understanding\` heading.
+6. **Validation** — run \`validate_guide\` tool (always at end of new-assignment / import-source / reorder workflows). Optionally delegate to \`@validator\` for content review when scope warrants.
+7. **Done** — summarize what was built and any flagged issues.
+
+### Parallelism
+
+Only fan out where work is independent — page drafting (Phase 4) and assessment authoring (Phase 5). Don't parallelize across phases; respect ordering dependencies.
+
+### Tool routing — when to call vs. when to delegate
+
+- New page JSON+MD pair → \`@page-author\` (draft mode) returns body+metadata → you call \`create_page\`. **Do not** hand-write the JSON.
+- Existing page surgical edit → \`@page-author\` (revise mode) edits the .md directly. No tool call.
+- New assessment → \`@assessment-author\` returns payload → you call \`create_assessment\` → you splice the returned \`embedLine\` into the page.
+- \`order\` array updates → you edit the index.json yourself with the edit tool. Small contextual JSON; no tool needed.
+- Stem generation (kebab-slug + 4-hex) → you generate inline. No tool.
+</Workflow>
+
+<Approval Gates>
+
+The outline gate is the **only** blocking approval. Other intents follow this policy:
+
+- **Auto-run** when intent and required inputs are unambiguous (add-page with clear title+parent, add-assessment with clear type+topic+target, additive revise-page edits).
+- **Restate and go** for reorders and prose-overwriting revisions — restate the new position / replacement in one sentence; proceed unless the user corrects within their next message.
+- **Pause** when required inputs are missing — ask inline using the relevant workflow's intake step. Do not bounce to a different workflow.
+- **Never** write to \`.guides/content/\` or \`.guides/assessments/\` before the outline gate is passed for new-assignment / import-source.
+</Approval Gates>
+
+<OpenCode Subagent Execution Model>
+
+- A delegated subagent runs in a separate child session.
+- Delegation is blocking for the parent at that point: send work out, then continue after results return.
+- Parallel delegation means launching multiple independent child-session branches.
+- Only parallelize branches that are truly independent. Reconcile dependent steps after results come back.
+</OpenCode Subagent Execution Model>
+
+<Communication>
+
+- Concise execution. Answer directly, no preamble.
+- One-line delegation notices: "Drafting page via @page-author..." not multi-sentence preludes.
+- No flattery. Never "Great idea!" or "Excellent choice!" or any praise of user input.
+- Honest pushback: when the user's approach seems problematic, state concern + alternative briefly, ask if they want to proceed.
+- Don't summarize what you did unless asked.
+- When subagent or tool returns an error, surface it. Don't silently continue with partial state.
+</Communication>
+`;
+}
+function createCodioOrchestratorAgent(model, customPrompt, customAppendPrompt, disabledAgents) {
+  const base = buildOrchestratorPrompt(disabledAgents);
+  const prompt = resolvePrompt(base, customPrompt, customAppendPrompt);
+  return {
+    name: "codio-orchestrator",
+    description: "Primary orchestrator for Codio guide authoring. Owns the workflow lifecycle, the outline approval gate, and routing to subagents/tools.",
+    config: {
+      mode: "primary",
+      temperature: 0.1,
+      model,
+      prompt,
+      permission: {
+        question: "allow"
+      }
+    }
+  };
+}
+
+// src/agents/outline-architect.ts
+var BASE_PROMPT2 = `# Outline Architect
+
+You design Codio assignment structure. The orchestrator hands you intake (topic, audience, LOs, constraints) and optionally a source digest from \`source-ingester\`. You return a proposed outline as markdown. You **do not** write files.
+
+## Domain constraints
+
+- Assignments are **flat (no chapter)** or **single-chapter**. Never propose multiple chapters.
+- Single approval gate: the user must approve your outline before any files get written downstream.
+
+## Output format
+
+\`\`\`markdown
+# Outline: <assignment title>
+
+**Audience:** <one line>
+**Learning objectives:**
+- <LO 1>
+- <LO 2>
+- ...
+
+## Structure
+
+<choose ONE of:>
+
+### Flat (no chapter)
+
+1. **<Page title>** — type: \`<intro|objectives|instructional|assessment|conclusion>\` — LO: <which LO(s) this addresses or "n/a"> — assessment: <none | inline | dedicated page>
+2. ...
+
+### Single-chapter
+
+**Chapter:** <chapter title>
+
+1. **<Page title>** — type: ... — LO: ... — assessment: ...
+2. ...
+\`\`\`
+
+## Rules
+
+- Propose one structural shape (flat or single-chapter); do not offer both.
+- Map every LO to at least one page.
+- Prefer instructional pages before assessment pages; concept before practice.
+- If the brief is ambiguous, ask before designing — do not silently choose.
+- Do not write JSON or filesystem paths. Just the outline.
+- Do not make up LOs the user didn't provide. If the user didn't supply LOs, derive 3-5 candidate LOs from the topic and source digest and clearly mark them as candidates.
+- Don't pad. If the topic only justifies 4 pages, propose 4 pages.
+
+## What you don't do
+
+- Write any files. Output is markdown for the orchestrator to show the user.
+- Write page content. You only design structure and LOs.
+- Pick UUIDs, taskIds, or filenames. The orchestrator handles those after approval.
+`;
+function createOutlineArchitectAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(BASE_PROMPT2, customPrompt, customAppendPrompt);
+  return {
+    name: "outline-architect",
+    description: "Designs Codio assignment structure (flat or single-chapter) and LOs; returns a markdown outline. Does not write files.",
+    config: {
+      mode: "subagent",
+      model,
+      permission: {
+        read: "allow",
+        bash: "deny",
+        write: "deny",
+        edit: "deny"
+      },
+      prompt
+    }
+  };
+}
+
+// src/agents/page-author.ts
+var BASE_PROMPT3 = `# Page Author
+
+You write one Codio guide page at a time. You operate in two modes:
+
+- **Draft mode** — given a brief (page title, type, LO(s), surrounding context), produce a markdown body and the metadata fields. **Do not write JSON or files directly.** Return the body + metadata to the orchestrator; the \`create_page\` tool stamps the JSON and writes both files.
+- **Revise mode** — given a page stem and a description of the requested change, apply a **surgical edit** to the existing \`.md\` using the edit tool. Do not modify the JSON unless the orchestrator says so.
+
+## Draft mode inputs
+
+The orchestrator gives you:
+- \`stem\` — already chosen; do not change it.
+- \`title\`, \`type\`, \`layout\`, \`learningObjectives\`.
+- \`body_brief\` — bullets describing what the page should cover.
+- \`assignment_context\` — short summary of the assignment and what came before this page.
+
+What you return:
+- \`markdownBody\` — the full instructional prose.
+- The metadata fields the orchestrator passes to \`create_page\`: title, type, layout (default \`1-panel\` unless told \`2-panels-tree\` + \`files\`), learningObjectives.
+
+You do **not** insert assessment embed strings. The orchestrator inserts those after \`assessment-author\` returns.
+
+## Style rules
+
+- Heading 1 = page title (matches the JSON \`title\`).
+- One concept per page. If you find yourself introducing a second major concept, stop — that's a separate page.
+- Worked examples in fenced code blocks with a language label.
+- "You" not "the student". Active voice. No filler.
+- Cross-page references use the page title verbatim, not "previous/next page" — order can change.
+
+## Revise mode
+
+1. Read \`.guides/content/<stem>.md\`.
+2. Identify the smallest contiguous region affected by the requested change. Apply the edit; leave everything else byte-identical.
+3. If the change requires a new assessment embed, do NOT add it — return the request to the orchestrator.
+4. Return a one-line summary of the change applied.
+
+### Revise rules
+
+- Surgical, not wholesale.
+- Never silently change LOs, callout types, or examples that weren't part of the request.
+- If the requested change amounts to a rewrite, say so back to the orchestrator and stop.
+
+## What you don't do
+
+- Write JSON files (orchestrator + \`create_page\` tool).
+- Update \`order\` arrays (orchestrator).
+- Insert assessment embed strings (orchestrator).
+- Author assessments (that's \`assessment-author\`).
+- Write multiple pages. One call, one page.
+`;
+function createPageAuthorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(BASE_PROMPT3, customPrompt, customAppendPrompt);
+  return {
+    name: "page-author",
+    description: "Writes Codio guide page markdown (draft mode produces body+metadata for create_page; revise mode applies surgical edits to existing .md).",
+    config: {
+      mode: "subagent",
+      model,
+      permission: {
+        read: "allow",
+        edit: "allow",
+        write: "deny",
+        bash: "deny"
+      },
+      prompt
+    }
+  };
+}
+
+// src/agents/source-ingester.ts
+var BASE_PROMPT4 = `# Source Ingester
+
+You read source material (a file path, a URL, or pasted text) and produce a structured digest the orchestrator can hand to \`outline-architect\` or \`page-author\`.
+
+## Default materials location
+
+Uploaded materials live under \`.guides/secure/materials/\`. If the orchestrator passes a relative path with no directory, look there first.
+
+## Inputs
+
+- \`source\`: a path, URL, or inline text block.
+- \`focus\` (optional): what the orchestrator wants extracted (concepts, examples, exercises, etc).
+
+## Output
+
+Return a digest as markdown:
+
+\`\`\`markdown
+## Source: <name or URL>
+
+**Format:** <pdf | url | code | text | ...>
+**Length / size:** <one line>
+
+### Key concepts
+- <concept 1>: <one-sentence summary>
+- ...
+
+### Worked examples or notable exercises
+- <one-line description, with section/page if applicable>
+- ...
+
+### Suggested LO seeds (optional)
+- <draft LO 1>
+- ...
+\`\`\`
+
+## Rules
+
+- Never paraphrase wholesale. Summarize and structure.
+- Quote verbatim only when the source's exact wording matters (e.g. a definition).
+- If the source is unreachable or unreadable, say so back to the orchestrator and stop.
+- Do not write files. Digest only.
+`;
+function createSourceIngesterAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(BASE_PROMPT4, customPrompt, customAppendPrompt);
+  return {
+    name: "source-ingester",
+    description: "Reads source material (file, URL, paste) and returns a structured markdown digest.",
+    config: {
+      mode: "subagent",
+      model,
+      permission: {
+        read: "allow",
+        bash: "allow",
+        write: "deny",
+        edit: "deny"
+      },
+      prompt
+    }
+  };
+}
+
+// src/agents/validator.ts
+var BASE_PROMPT5 = `# Validator
+
+You do **content-quality review** of a Codio guide. The deterministic structural checks (UUID format, order array integrity, broken embed references, taskId/filename mismatch) live in the \`validate_guide\` **tool** — the orchestrator runs that first. Your job is what the tool can't do: pedagogy, clarity, LO alignment.
+
+## Inputs
+
+- \`from_pipeline\`: boolean. \`true\` when invoked at the end of a full pipeline (auto-validation); \`false\` when invoked manually.
+- \`scope\` (optional): a specific page stem or chapter to focus on.
+
+## What you check
+
+For each page (or just the scoped ones):
+1. **LO alignment** — does the page actually teach what its \`learningObjectives\` claim?
+2. **Concept scope** — one concept per page; flag pages introducing more than one major idea.
+3. **Cognitive ramp** — are prerequisite ideas introduced before they're used?
+4. **Examples** — does each new abstraction have at least one concrete worked example?
+5. **Assessment fit** — do embedded assessments test the LO the page taught, not something tangential?
+6. **Style** — concise, active voice, "you" not "the student"; no filler; callouts used purposefully.
+7. **Cross-references** — links to other pages use page title verbatim, not "previous/next".
+
+## Output
+
+Return a structured report as markdown:
+
+\`\`\`markdown
+## Validator report
+
+**Pages reviewed:** N
+**Issues flagged:** M
+
+### <Page title> (\`<stem>\`)
+- **<category>**: <one-line description>
+- ...
+\`\`\`
+
+Categories: \`lo-mismatch\`, \`concept-scope\`, \`ramp\`, \`missing-example\`, \`assessment-fit\`, \`style\`, \`cross-reference\`.
+
+## What you don't do
+
+- Write files. Report only.
+- Re-run the structural checks the tool already ran — point to that report instead.
+- Fix anything. The orchestrator routes fixes back through \`page-author\` or \`assessment-author\` after the user decides.
+`;
+function createValidatorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(BASE_PROMPT5, customPrompt, customAppendPrompt);
+  return {
+    name: "validator",
+    description: "Content-quality review (pedagogy, LO alignment, clarity). Deterministic checks live in the validate_guide tool.",
+    config: {
+      mode: "subagent",
+      model,
+      permission: {
+        read: "allow",
+        bash: "deny",
+        write: "deny",
+        edit: "deny"
+      },
+      prompt
+    }
+  };
+}
+
+// src/agents/index.ts
+var FACTORIES = [
+  {
+    name: "codio-orchestrator",
+    factory: createCodioOrchestratorAgent,
+    defaultModelTier: "primary"
+  },
+  {
+    name: "outline-architect",
+    factory: createOutlineArchitectAgent,
+    defaultModelTier: "primary"
+  },
+  {
+    name: "page-author",
+    factory: createPageAuthorAgent,
+    defaultModelTier: "primary"
+  },
+  {
+    name: "assessment-author",
+    factory: createAssessmentAuthorAgent,
+    defaultModelTier: "primary"
+  },
+  {
+    name: "source-ingester",
+    factory: createSourceIngesterAgent,
+    defaultModelTier: "cheap"
+  },
+  {
+    name: "validator",
+    factory: createValidatorAgent,
+    defaultModelTier: "primary"
+  }
+];
+function getDisabledAgents(config) {
+  return new Set(config.disabledAgents);
+}
+function createAgents(config) {
+  const disabled = getDisabledAgents(config);
+  const agents = [];
+  for (const { name, factory, defaultModelTier } of FACTORIES) {
+    if (disabled.has(name))
+      continue;
+    const override = config.agents[name];
+    const model = override?.model ?? config.defaultModels[defaultModelTier];
+    const definition = factory(model, override?.prompt, override?.appendPrompt, name === "codio-orchestrator" ? disabled : undefined);
+    if (override?.temperature !== undefined) {
+      definition.config.temperature = override.temperature;
+    }
+    agents.push(definition);
+  }
+  return agents;
+}
+function getAgentConfigs(agents) {
+  const map = {};
+  for (const a of agents)
+    map[a.name] = a.config;
+  return map;
+}
+
+// src/config/index.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+var DEFAULT_PRIMARY = "amazon-bedrock/sonnet-4-6";
+var DEFAULT_CHEAP = "amazon-bedrock/haiku-4-5";
+var agentOverrideSchema = z.object({
+  model: z.string().optional(),
+  prompt: z.string().optional(),
+  appendPrompt: z.string().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  skills: z.array(z.string()).optional()
+});
+var pluginConfigSchema = z.object({
+  agents: z.record(z.string(), agentOverrideSchema).default(() => ({})),
+  disabledAgents: z.array(z.string()).default(() => []),
+  defaultModels: z.object({
+    primary: z.string().default(DEFAULT_PRIMARY),
+    cheap: z.string().default(DEFAULT_CHEAP)
+  }).default(() => ({
+    primary: DEFAULT_PRIMARY,
+    cheap: DEFAULT_CHEAP
+  }))
+}).default(() => ({
+  agents: {},
+  disabledAgents: [],
+  defaultModels: { primary: DEFAULT_PRIMARY, cheap: DEFAULT_CHEAP }
+}));
+function loadPluginConfig(directory) {
+  const candidate = join(directory, "codio-authoring.json");
+  if (!existsSync(candidate)) {
+    return pluginConfigSchema.parse({});
+  }
+  const text = readFileSync(candidate, "utf8");
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid JSON in ${candidate}: ${msg}`);
+  }
+  try {
+    return pluginConfigSchema.parse(raw);
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      const detail = err.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+      throw new Error(`Invalid config in ${candidate}: ${detail}`);
+    }
+    throw err;
+  }
+}
+
+// src/config/bedrock-models.ts
+var DEFAULT_BEDROCK_MODELS = {
+  "sonnet-4-6": {
+    id: "us.anthropic.claude-sonnet-4-6",
+    name: "Claude Sonnet 4.6 (US cross-region)"
+  },
+  "haiku-4-5": {
+    id: "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+    name: "Claude Haiku 4.5 (US cross-region)"
+  }
+};
+
+// src/tools/index.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/tools/create-assessment.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join as join3 } from "node:path";
+import { z as z2 } from "zod";
+
+// src/utils/codio-paths.ts
+import { join as join2 } from "node:path";
+function resolveCodioPaths(ctx) {
+  const workspace = ctx.directory.replace(/\/+$/, "");
+  return {
+    workspace,
+    guides: join2(workspace, ".guides"),
+    content: join2(workspace, ".guides", "content"),
+    assessments: join2(workspace, ".guides", "assessments"),
+    secure: join2(workspace, ".guides", "secure"),
+    materials: join2(workspace, ".guides", "secure", "materials"),
+    pluginDir: join2(workspace, ".guides", "secure", "codio-authoring-opencode")
+  };
+}
+
+// src/utils/taskid.ts
+import { randomInt } from "node:crypto";
+var ASSESSMENT_TYPES = [
+  "multiple-choice",
+  "code-output-compare",
+  "fill-in-the-blanks",
+  "parsons-puzzle",
+  "llm-based-auto-rubric"
+];
+var TASKID_RE = new RegExp(`^(${ASSESSMENT_TYPES.join("|")})-[1-9][0-9]{9}$`);
+var ANY_TASKID_RE = new RegExp(`(?:${ASSESSMENT_TYPES.join("|")})-[1-9][0-9]{9}`, "g");
+function generateTaskId(type) {
+  const first = randomInt(1, 10);
+  const rest = randomInt(0, 1e9).toString().padStart(9, "0");
+  return `${type}-${first}${rest}`;
+}
+
+// src/utils/uuid.ts
+import { randomUUID } from "node:crypto";
+var UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function generateUuidV4() {
+  return randomUUID();
+}
+function isUuidV4(value) {
+  return UUID_V4_RE.test(value);
+}
+
+// src/tools/create-assessment.ts
+var ASSESSMENT_TYPE_TAG = {
+  "multiple-choice": "Multiple Choice",
+  "code-output-compare": "Standard Code Test",
+  "fill-in-the-blanks": "Fill in the Blanks",
+  "parsons-puzzle": "Parsons Puzzle",
+  "llm-based-auto-rubric": null
+};
+function ensureAssessmentTag(tags, type) {
+  const list = tags ? [...tags] : [];
+  const tagValue = ASSESSMENT_TYPE_TAG[type];
+  if (tagValue !== null && !list.some((t) => t.name === "Assessment Type")) {
+    list.unshift({ name: "Assessment Type", value: tagValue });
+  }
+  return list;
+}
+var tagSchema = z2.object({ name: z2.string(), value: z2.string() });
+var mcqPayloadSchema = z2.object({
+  name: z2.string().default(""),
+  instructions: z2.string().min(1),
+  answers: z2.array(z2.object({ answer: z2.string(), correct: z2.boolean().default(false) })).min(1),
+  multiple_response: z2.boolean().default(false),
+  randomize: z2.boolean().default(true),
+  tags: z2.array(tagSchema).optional(),
+  blooms: z2.string().default(""),
+  lo: z2.string().default(""),
+  guidance: z2.string().default(""),
+  max_attempts: z2.number().int().positive().default(1),
+  points: z2.number().int().nonnegative().default(20)
+}).refine((p) => p.answers.some((a) => a.correct), {
+  message: "multiple-choice payload must mark at least one correct answer",
+  path: ["answers"]
+});
+function buildMcqAssessment(raw, taskId = generateTaskId("multiple-choice")) {
+  const p = mcqPayloadSchema.parse(raw);
+  return {
+    type: "multiple-choice",
+    taskId,
+    source: {
+      name: p.name,
+      showName: true,
+      instructions: p.instructions,
+      multipleResponse: p.multiple_response,
+      isRandomized: p.randomize,
+      answers: p.answers.map((a) => ({
+        _id: generateUuidV4(),
+        correct: a.correct,
+        answer: a.answer
+      })),
+      metadata: {
+        tags: ensureAssessmentTag(p.tags, "multiple-choice"),
+        files: [],
+        opened: []
+      },
+      bloomsObjectiveLevel: p.blooms,
+      learningObjectives: p.lo,
+      guidance: p.guidance,
+      showGuidanceAfterResponseOption: { type: "Attempts", passedFrom: 1 },
+      maxAttemptsCount: p.max_attempts,
+      showExpectedAnswerOption: { type: "Always" },
+      points: p.points,
+      incorrectPoints: 0,
+      arePartialPointsAllowed: false,
+      useMaximumScore: false
+    }
+  };
+}
+var codeTestPayloadSchema = z2.object({
+  name: z2.string().default(""),
+  command: z2.string().min(1),
+  test_cases: z2.array(z2.object({
+    input: z2.string().default(""),
+    output: z2.string().default(""),
+    arguments: z2.string().default(""),
+    feedback: z2.string().default(""),
+    show_feedback: z2.boolean().default(false)
+  })).default([]),
+  starter_file_path: z2.string().default(""),
+  starter_file_content: z2.string().optional(),
+  options: z2.object({
+    ignoreCase: z2.boolean().default(true),
+    ignoreNewline: z2.boolean().default(true),
+    ignoreWhitespaces: z2.boolean().default(true),
+    matchSubstring: z2.boolean().default(true),
+    timeout: z2.number().int().positive().default(30)
+  }).default(() => ({
+    ignoreCase: true,
+    ignoreNewline: true,
+    ignoreWhitespaces: true,
+    matchSubstring: true,
+    timeout: 30
+  })),
+  pre_execute_command: z2.string().default(""),
+  one_time_test: z2.boolean().default(true),
+  partial_points: z2.boolean().default(true),
+  show_name: z2.boolean().default(false),
+  show_expected_answer: z2.boolean().default(true),
+  show_guidance_after_response: z2.boolean().default(true),
+  instructions: z2.string().default("Submit your code when ready"),
+  tags: z2.array(tagSchema).optional(),
+  blooms: z2.string().default(""),
+  lo: z2.string().default(""),
+  guidance: z2.string().default(""),
+  points: z2.number().int().nonnegative().default(20)
+});
+function buildCodeTestAssessment(raw, taskId = generateTaskId("code-output-compare")) {
+  const p = codeTestPayloadSchema.parse(raw);
+  const files = p.starter_file_path ? [p.starter_file_path] : [];
+  const opened = p.starter_file_path ? [{ content: p.starter_file_path, panelNumber: 0, type: "file" }] : [];
+  return {
+    type: "code-output-compare",
+    taskId,
+    source: {
+      arePartialPointsAllowed: p.partial_points,
+      bloomsObjectiveLevel: p.blooms,
+      command: p.command,
+      guidance: p.guidance,
+      instructions: p.instructions,
+      learningObjectives: p.lo,
+      metadata: {
+        files,
+        opened,
+        tags: ensureAssessmentTag(p.tags, "code-output-compare")
+      },
+      name: p.name,
+      oneTimeTest: p.one_time_test,
+      options: p.options,
+      points: p.points,
+      preExecuteCommand: p.pre_execute_command,
+      sequence: p.test_cases.map((tc) => ({
+        arguments: tc.arguments,
+        feedback: tc.feedback,
+        input: tc.input,
+        output: tc.output,
+        showFeedback: tc.show_feedback
+      })),
+      showExpectedAnswer: p.show_expected_answer,
+      showGuidanceAfterResponse: p.show_guidance_after_response,
+      showName: p.show_name
+    }
+  };
+}
+var FITB_BLANK_RE = /<<<(.+?)>>>/g;
+function parseFitbText(raw) {
+  const blank = [];
+  const text = [];
+  let pos = 0;
+  for (const m of raw.matchAll(FITB_BLANK_RE)) {
+    if (m.index !== undefined && m.index > pos) {
+      text.push(raw.slice(pos, m.index));
+    }
+    text.push(0);
+    blank.push(m[1]);
+    pos = (m.index ?? 0) + m[0].length;
+  }
+  if (pos < raw.length)
+    text.push(raw.slice(pos));
+  return { blank, text };
+}
+var fitbPayloadSchema = z2.object({
+  name: z2.string().default(""),
+  instructions: z2.string().min(1),
+  text: z2.string().min(1),
+  show_name: z2.boolean().default(true),
+  show_values: z2.boolean().default(true),
+  distractors: z2.string().default(""),
+  tags: z2.array(tagSchema).optional(),
+  blooms: z2.string().default(""),
+  lo: z2.string().default(""),
+  guidance: z2.string().default(""),
+  max_attempts: z2.number().int().positive().default(1),
+  points: z2.number().int().nonnegative().default(20),
+  partial_points: z2.boolean().default(false)
+}).refine((p) => /<<<.+?>>>/.test(p.text), {
+  message: "fill-in-the-blanks text must contain at least one <<<answer>>> marker",
+  path: ["text"]
+});
+function buildFitbAssessment(raw, taskId = generateTaskId("fill-in-the-blanks")) {
+  const p = fitbPayloadSchema.parse(raw);
+  const tokens = parseFitbText(p.text);
+  return {
+    type: "fill-in-the-blanks",
+    taskId,
+    source: {
+      name: p.name,
+      showName: p.show_name,
+      instructions: p.instructions,
+      showValues: p.show_values,
+      text: p.text,
+      distractors: p.distractors,
+      metadata: {
+        tags: ensureAssessmentTag(p.tags, "fill-in-the-blanks"),
+        files: [],
+        opened: []
+      },
+      bloomsObjectiveLevel: p.blooms,
+      learningObjectives: p.lo,
+      guidance: p.guidance,
+      showGuidanceAfterResponseOption: { type: "Attempts", passedFrom: 1 },
+      maxAttemptsCount: p.max_attempts,
+      showExpectedAnswerOption: { type: "Always" },
+      points: p.points,
+      arePartialPointsAllowed: p.partial_points,
+      useMaximumScore: false,
+      tokens: { ...tokens, regexPositions: [] }
+    }
+  };
+}
+var parsonsOptionsSchema = z2.object({
+  sortableId: z2.string().default("sortable"),
+  max_wrong_lines: z2.number().int().nonnegative().default(10),
+  exec_limit: z2.number().int().nonnegative().default(2500),
+  can_indent: z2.boolean().default(true),
+  x_indent: z2.number().int().nonnegative().default(50),
+  lang: z2.string().default("en"),
+  show_feedback: z2.boolean().default(true),
+  python3: z2.boolean().default(true),
+  trashId: z2.string().default("sortableTrash")
+});
+var parsonsPayloadSchema = z2.object({
+  name: z2.string().optional(),
+  instructions: z2.string().min(1),
+  initial: z2.string().min(1),
+  options: parsonsOptionsSchema.optional(),
+  grader: z2.string().default("1"),
+  points: z2.number().int().nonnegative().default(20),
+  blooms: z2.string().default(""),
+  lo: z2.string().default(""),
+  guidance: z2.string().default(""),
+  max_attempts: z2.number().int().nonnegative().default(0),
+  use_maximum_score: z2.boolean().default(false),
+  tags: z2.array(tagSchema).optional(),
+  show_name: z2.boolean().default(true),
+  show_guidance_after_attempts: z2.number().int().nonnegative().default(2)
+});
+function buildParsonsAssessment(raw, taskId = generateTaskId("parsons-puzzle")) {
+  const p = parsonsPayloadSchema.parse(raw);
+  const opts = parsonsOptionsSchema.parse(p.options ?? {});
+  return {
+    type: "parsons-puzzle",
+    taskId,
+    source: {
+      name: p.name ?? taskId,
+      showName: p.show_name,
+      instructions: p.instructions,
+      initial: p.initial,
+      options: JSON.stringify(opts),
+      grader: p.grader,
+      metadata: {
+        tags: ensureAssessmentTag(p.tags, "parsons-puzzle"),
+        files: [],
+        opened: []
+      },
+      bloomsObjectiveLevel: p.blooms,
+      learningObjectives: p.lo,
+      guidance: p.guidance,
+      showGuidanceAfterResponseOption: {
+        type: "Attempts",
+        passedFrom: p.show_guidance_after_attempts
+      },
+      maxAttemptsCount: p.max_attempts,
+      points: p.points,
+      useMaximumScore: p.use_maximum_score
+    }
+  };
+}
+var llmAutoRubricRubricSchema = z2.object({
+  id: z2.string().optional(),
+  title: z2.string().min(1),
+  description: z2.string().min(1),
+  points: z2.number()
+});
+var llmAutoRubricSolutionSchema = z2.object({
+  path: z2.string().min(1),
+  content: z2.string()
+});
+var llmAutoRubricPayloadSchema = z2.object({
+  name: z2.string().optional(),
+  instructions: z2.string().min(1),
+  files: z2.array(z2.string()).default([]),
+  rubrics: z2.array(llmAutoRubricRubricSchema).min(1),
+  rubrics_requirements: z2.string().default(""),
+  solutions: z2.array(llmAutoRubricSolutionSchema).default([]),
+  points: z2.number().int().nonnegative().default(5),
+  partial_points: z2.boolean().default(true),
+  blooms: z2.string().default(""),
+  lo: z2.string().default(""),
+  guidance: z2.string().default(""),
+  max_attempts: z2.number().int().nonnegative().default(0),
+  tags: z2.array(tagSchema).optional(),
+  show_name: z2.boolean().default(false),
+  show_guidance_after_attempts: z2.number().int().nonnegative().default(2)
+});
+function buildLlmAutoRubricAssessment(raw, taskId = generateTaskId("llm-based-auto-rubric")) {
+  const p = llmAutoRubricPayloadSchema.parse(raw);
+  const opened = p.files.map((f) => ({
+    type: "file",
+    panelNumber: 0,
+    content: f
+  }));
+  return {
+    type: "llm-based-auto-rubric",
+    taskId,
+    source: {
+      name: p.name ?? taskId,
+      showName: p.show_name,
+      instructions: p.instructions,
+      metadata: {
+        tags: ensureAssessmentTag(p.tags, "llm-based-auto-rubric"),
+        files: p.files,
+        opened
+      },
+      bloomsObjectiveLevel: p.blooms,
+      learningObjectives: p.lo,
+      guidance: p.guidance,
+      showGuidanceAfterResponseOption: {
+        type: "Attempts",
+        passedFrom: p.show_guidance_after_attempts
+      },
+      maxAttemptsCount: p.max_attempts,
+      points: p.points,
+      arePartialPointsAllowed: p.partial_points,
+      rubrics: p.rubrics.map((r, i) => ({
+        id: r.id ?? String(i + 1),
+        title: r.title,
+        description: r.description,
+        points: r.points
+      })),
+      rubricsRequirements: p.rubrics_requirements,
+      solutions: p.solutions
+    }
+  };
+}
+var createAssessmentInputSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("multiple-choice"),
+    workspace: z2.string().min(1),
+    payload: z2.unknown()
+  }),
+  z2.object({
+    type: z2.literal("code-output-compare"),
+    workspace: z2.string().min(1),
+    payload: z2.unknown()
+  }),
+  z2.object({
+    type: z2.literal("fill-in-the-blanks"),
+    workspace: z2.string().min(1),
+    payload: z2.unknown()
+  }),
+  z2.object({
+    type: z2.literal("parsons-puzzle"),
+    workspace: z2.string().min(1),
+    payload: z2.unknown()
+  }),
+  z2.object({
+    type: z2.literal("llm-based-auto-rubric"),
+    workspace: z2.string().min(1),
+    payload: z2.unknown()
+  })
+]);
+async function createAssessmentHandler(raw) {
+  const input = createAssessmentInputSchema.parse(raw);
+  const { assessments, workspace } = resolveCodioPaths({
+    directory: input.workspace
+  });
+  let json;
+  let name;
+  let codeStarter = null;
+  let llmSolutions = [];
+  if (input.type === "multiple-choice") {
+    const taskId = generateTaskId("multiple-choice");
+    json = buildMcqAssessment(input.payload, taskId);
+    name = json.source.name || taskId;
+  } else if (input.type === "code-output-compare") {
+    const taskId = generateTaskId("code-output-compare");
+    json = buildCodeTestAssessment(input.payload, taskId);
+    name = json.source.name || taskId;
+    const parsed = codeTestPayloadSchema.parse(input.payload);
+    if (parsed.starter_file_path && parsed.starter_file_content !== undefined) {
+      codeStarter = {
+        path: parsed.starter_file_path,
+        content: parsed.starter_file_content
+      };
+    }
+  } else if (input.type === "fill-in-the-blanks") {
+    const taskId = generateTaskId("fill-in-the-blanks");
+    json = buildFitbAssessment(input.payload, taskId);
+    name = json.source.name || taskId;
+  } else if (input.type === "parsons-puzzle") {
+    const taskId = generateTaskId("parsons-puzzle");
+    json = buildParsonsAssessment(input.payload, taskId);
+    name = json.source.name || taskId;
+  } else if (input.type === "llm-based-auto-rubric") {
+    const taskId = generateTaskId("llm-based-auto-rubric");
+    json = buildLlmAutoRubricAssessment(input.payload, taskId);
+    name = json.source.name || taskId;
+    const parsed = llmAutoRubricPayloadSchema.parse(input.payload);
+    llmSolutions = parsed.solutions;
+  } else {
+    throw new Error(`unsupported assessment type: ${input.type}`);
+  }
+  const jsonPath = join3(assessments, `${json.taskId}.json`);
+  try {
+    writeFileSync(jsonPath, `${JSON.stringify(json, null, 2)}
+`, {
+      flag: "wx"
+    });
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      throw new Error(`taskId collision at ${jsonPath}`);
+    }
+    throw err;
+  }
+  if (codeStarter) {
+    const starterPath = join3(workspace, codeStarter.path);
+    if (!existsSync2(starterPath)) {
+      mkdirSync(dirname(starterPath), { recursive: true });
+      writeFileSync(starterPath, codeStarter.content);
+    }
+  }
+  for (const solution of llmSolutions) {
+    const solPath = join3(workspace, solution.path);
+    if (!existsSync2(solPath)) {
+      mkdirSync(dirname(solPath), { recursive: true });
+      writeFileSync(solPath, solution.content);
+    }
+  }
+  return {
+    taskId: json.taskId,
+    jsonPath,
+    embedLine: `{${name} |assessment}(${json.taskId})`
+  };
+}
+
+// src/tools/create-page.ts
+import { unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+import { z as z3 } from "zod";
+var PAGE_TYPES = [
+  "intro",
+  "objectives",
+  "instructional",
+  "assessment",
+  "conclusion"
+];
+var PAGE_LAYOUTS = ["1-panel", "2-panels-tree"];
+var createPageInputSchema = z3.object({
+  workspace: z3.string().min(1),
+  stem: z3.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "stem must be kebab-case"),
+  title: z3.string().min(1),
+  type: z3.enum(PAGE_TYPES),
+  layout: z3.enum(PAGE_LAYOUTS),
+  learningObjectives: z3.array(z3.string()).default([]),
+  files: z3.array(z3.string()).optional(),
+  markdownBody: z3.string(),
+  chapterFolder: z3.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "chapterFolder must be a kebab-case directory name (no slashes, no ..)").optional()
+}).refine((v) => v.layout !== "2-panels-tree" || v.files && v.files.length > 0, { message: "layout=2-panels-tree requires files", path: ["files"] });
+function buildPageJson(input) {
+  const files = input.layout === "2-panels-tree" && input.files && input.files.length > 0 ? input.files.map((path) => ({ path, panel: 0, action: "open" })) : [];
+  return {
+    id: generateUuidV4(),
+    title: input.title,
+    type: "page",
+    contentType: "markdown",
+    layout: input.layout,
+    files,
+    teacherOnly: false,
+    learningObjectives: input.learningObjectives.join("; ")
+  };
+}
+function writeCreatedPage(workspace, chapterFolder, input) {
+  const { content } = resolveCodioPaths({ directory: workspace });
+  const targetDir = chapterFolder ? join4(content, chapterFolder) : content;
+  const json = buildPageJson(input);
+  const jsonPath = join4(targetDir, `${input.stem}.json`);
+  const mdPath = join4(targetDir, `${input.stem}.md`);
+  try {
+    writeFileSync2(jsonPath, `${JSON.stringify(json, null, 2)}
+`, {
+      flag: "wx"
+    });
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      throw new Error(`stem already exists at ${targetDir}: ${input.stem}`);
+    }
+    throw err;
+  }
+  try {
+    writeFileSync2(mdPath, input.markdownBody, { flag: "wx" });
+  } catch (err) {
+    try {
+      unlinkSync(jsonPath);
+    } catch {}
+    if (err.code === "EEXIST") {
+      throw new Error(`stem already exists at ${targetDir}: ${input.stem}`);
+    }
+    throw err;
+  }
+  return { uuid: json.id, stem: input.stem, jsonPath, mdPath };
+}
+async function createPageHandler(raw) {
+  const input = createPageInputSchema.parse(raw);
+  return writeCreatedPage(input.workspace, input.chapterFolder, input);
+}
+
+// src/tools/validate-guide.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { join as join5, relative } from "node:path";
+import { z as z4 } from "zod";
+var validateGuideInputSchema = z4.object({
+  workspace: z4.string().min(1)
+});
+function walkJsonFiles(root) {
+  if (!existsSync3(root))
+    return [];
+  const out = [];
+  for (const name of readdirSync(root)) {
+    const p = join5(root, name);
+    const s = statSync(p);
+    if (s.isDirectory())
+      out.push(...walkJsonFiles(p));
+    else if (name.endsWith(".json"))
+      out.push(p);
+  }
+  return out;
+}
+function walkMdFiles(root) {
+  if (!existsSync3(root))
+    return [];
+  const out = [];
+  for (const name of readdirSync(root)) {
+    const p = join5(root, name);
+    const s = statSync(p);
+    if (s.isDirectory())
+      out.push(...walkMdFiles(p));
+    else if (name.endsWith(".md"))
+      out.push(p);
+  }
+  return out;
+}
+function collectIdFields(value, out) {
+  if (!value || typeof value !== "object")
+    return;
+  if (Array.isArray(value)) {
+    for (const v of value)
+      collectIdFields(v, out);
+    return;
+  }
+  const obj = value;
+  for (const [k, v] of Object.entries(obj)) {
+    if ((k === "id" || k === "_id") && typeof v === "string" && v.length > 0) {
+      out.push(v);
+    }
+    collectIdFields(v, out);
+  }
+}
+async function validateGuideHandler(raw) {
+  const input = validateGuideInputSchema.parse(raw);
+  const { guides, content, assessments } = resolveCodioPaths({
+    directory: input.workspace
+  });
+  const findings = [];
+  if (!existsSync3(content)) {
+    findings.push({
+      category: "missing_content_dir",
+      detail: `${content} does not exist`,
+      severity: "error"
+    });
+    return { findings, passed: false };
+  }
+  for (const f of walkJsonFiles(guides)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync2(f, "utf8"));
+    } catch {
+      continue;
+    }
+    const ids = [];
+    collectIdFields(parsed, ids);
+    for (const id of ids) {
+      if (!isUuidV4(id)) {
+        findings.push({
+          category: "invalid_uuid",
+          detail: `${relative(input.workspace, f)}: ${id}`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  for (const f of walkJsonFiles(content)) {
+    if (!f.endsWith("/index.json"))
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync2(f, "utf8"));
+    } catch {
+      continue;
+    }
+    const base = f.slice(0, -"/index.json".length);
+    for (const stem of parsed?.order ?? []) {
+      const jsonPair = existsSync3(join5(base, `${stem}.json`)) && existsSync3(join5(base, `${stem}.md`));
+      const chapter = existsSync3(join5(base, stem, "index.json"));
+      if (!jsonPair && !chapter) {
+        findings.push({
+          category: "orphan_order_stem",
+          detail: `${relative(input.workspace, f)} references missing stem '${stem}'`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  for (const md of walkMdFiles(content)) {
+    const body = readFileSync2(md, "utf8");
+    const re = new RegExp(ANY_TASKID_RE.source, "g");
+    for (const match of body.matchAll(re)) {
+      const tid = match[0];
+      if (!existsSync3(join5(assessments, `${tid}.json`))) {
+        findings.push({
+          category: "broken_assessment_ref",
+          detail: `${relative(input.workspace, md)} references missing ${tid}.json`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  if (existsSync3(assessments)) {
+    for (const f of walkJsonFiles(assessments)) {
+      if (!f.endsWith(".json"))
+        continue;
+      const expected = f.split("/").pop().replace(/\.json$/, "");
+      let parsed;
+      try {
+        parsed = JSON.parse(readFileSync2(f, "utf8"));
+      } catch {
+        continue;
+      }
+      const actual = parsed?.taskId ?? "";
+      if (expected !== actual) {
+        findings.push({
+          category: "taskid_filename_mismatch",
+          detail: `${relative(input.workspace, f)}: filename '${expected}' vs taskId '${actual}'`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return { findings, passed: findings.length === 0 };
+}
+
+// src/tools/index.ts
+var create_page = tool({
+  description: "Stamp a Codio page JSON (with v4 UUID) and write the markdown body to .guides/content/. Returns { uuid, stem, jsonPath, mdPath }.",
+  args: createPageInputSchema.shape,
+  async execute(args) {
+    return JSON.stringify(await createPageHandler(args));
+  }
+});
+var create_assessment = tool({
+  description: "Create a Codio assessment JSON of type multiple-choice, code-output-compare, or fill-in-the-blanks. Generates the taskId, writes to .guides/assessments/, returns { taskId, jsonPath, embedLine }.",
+  args: {
+    type: tool.schema.enum(["multiple-choice", "code-output-compare", "fill-in-the-blanks"]).describe("Assessment type"),
+    workspace: tool.schema.string().min(1).describe("Absolute path to the Codio workspace root"),
+    payload: tool.schema.unknown().describe("Assessment payload object (type-specific fields)")
+  },
+  async execute(args) {
+    return JSON.stringify(await createAssessmentHandler(args));
+  }
+});
+var validate_guide = tool({
+  description: "Run structural validation on a Codio guide directory. Checks UUIDs, order arrays, assessment embed references, and taskId/filename consistency. Returns { findings[], passed }.",
+  args: validateGuideInputSchema.shape,
+  async execute(args) {
+    return JSON.stringify(await validateGuideHandler(args));
+  }
+});
+var tools = {
+  create_page,
+  create_assessment,
+  validate_guide
+};
+
+// src/index.ts
+var CodioAuthoringPlugin = async (ctx) => {
+  const config = loadPluginConfig(ctx.directory);
+  const agentDefs = createAgents(config);
+  const agents = getAgentConfigs(agentDefs);
+  const disabledAgents = new Set(config.disabledAgents);
+  const sessionAgentMap = new Map;
+  return {
+    name: "codio-authoring-opencode",
+    agent: agents,
+    tool: tools,
+    config: async (opencodeConfig) => {
+      opencodeConfig.default_agent = "codio-orchestrator";
+      if (!opencodeConfig.provider)
+        opencodeConfig.provider = {};
+      const providerRoot = opencodeConfig.provider;
+      if (!providerRoot["amazon-bedrock"]) {
+        providerRoot["amazon-bedrock"] = { models: {} };
+      }
+      const bedrock = providerRoot["amazon-bedrock"];
+      if (!bedrock.models)
+        bedrock.models = {};
+      for (const [key, def] of Object.entries(DEFAULT_BEDROCK_MODELS)) {
+        if (!bedrock.models[key]) {
+          bedrock.models[key] = { ...def };
+        }
+      }
+      if (!opencodeConfig.agent) {
+        opencodeConfig.agent = { ...agents };
+      } else {
+        for (const [name, pluginAgent] of Object.entries(agents)) {
+          const existing = opencodeConfig.agent[name];
+          opencodeConfig.agent[name] = existing ? { ...pluginAgent, ...existing } : { ...pluginAgent };
+        }
+      }
+      if (!opencodeConfig.command)
+        opencodeConfig.command = {};
+      opencodeConfig.command["validate-guide"] = {
+        template: "Call the validate_guide tool for the current workspace",
+        description: "Run structural validation on the current Codio assignment"
+      };
+    },
+    "chat.message": async (input, output) => {
+      const agent = input.agent ?? output?.message?.agent;
+      if (agent)
+        sessionAgentMap.set(input.sessionID, agent);
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      const agentName = input.sessionID ? sessionAgentMap.get(input.sessionID) : undefined;
+      if (agentName !== "codio-orchestrator")
+        return;
+      const already = output.system.some((s) => typeof s === "string" && s.includes("Codio Authoring Orchestrator"));
+      if (already)
+        return;
+      const orchestratorDef = agentDefs.find((a) => a.name === "codio-orchestrator");
+      const orchestratorPrompt = typeof orchestratorDef?.config?.prompt === "string" ? orchestratorDef.config.prompt : buildOrchestratorPrompt(disabledAgents);
+      output.system[0] = orchestratorPrompt + (output.system[0] ? `
+
+${output.system[0]}` : "");
+    }
+  };
+};
+var src_default = CodioAuthoringPlugin;
+export {
+  src_default as default
+};