feat: remove LLM extract fallback, require YAML frontmatter

Agent output must contain valid YAML frontmatter matching the role schema.
If frontmatter parsing fails, the step fails immediately with a clear error
instead of falling back to an LLM extraction that can fabricate values.

The extract module remains as a public API export but is no longer used
in the agent run loop.

Breaking change: agents that relied on LLM extraction to produce valid
output will now fail. They must output proper frontmatter.

.workflows/solve-issue.yaml

@@ -20,7 +20,7 @@ roles:
       2. Revise the test spec accordingly
 
       After producing the test spec:
-      1. Store it via `uwf cas put-text "<markdown content>"` and capture the returned hash
+      1. Store it via `uwf cas put "<markdown content>"` and capture the returned hash
       2. Put the hash in meta.plan (required when status=ready)
     output: "Output a brief summary of the test spec. Frontmatter must include: status (ready or insufficient_info) and plan (CAS hash of the test spec, required when status=ready)."
     frontmatter:

packages/cli-workflow/src/cli.ts

@@ -7,7 +7,6 @@ import {
   cmdCasGet,
   cmdCasHas,
   cmdCasPut,
-  cmdCasPutText,
   cmdCasRefs,
   cmdCasReindex,
   cmdCasSchemaGet,
@@ -296,17 +295,6 @@ cas
     });
   });
 
-cas
-  .command("put-text")
-  .description("Store a plain text string, print its hash")
-  .argument("<text>", "Text content to store")
-  .action((text: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasPutText(storageRoot, text));
-    });
-  });
-
 cas
   .command("has")
   .description("Check if a hash exists")

packages/cli-workflow/src/commands/cas.ts

@@ -2,11 +2,9 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import type { JSONSchema, Store } from "@uncaged/json-cas";
-import { bootstrap, getSchema, putSchema, refs, walk } from "@uncaged/json-cas";
+import { bootstrap, getSchema, refs, walk } from "@uncaged/json-cas";
 import { createFsStore } from "@uncaged/json-cas-fs";
 
-import { TEXT_SCHEMA } from "../schemas.js";
-
 // ---- Helpers ----
 
 function openStore(storageRoot: string): Store {
@@ -123,10 +121,3 @@ export async function cmdCasSchemaGet(storageRoot: string, hash: string): Promis
   }
   return schema;
 }
-
-export async function cmdCasPutText(storageRoot: string, text: string): Promise<{ hash: string }> {
-  const store = openStore(storageRoot);
-  const typeHash = await putSchema(store, TEXT_SCHEMA);
-  const hash = await store.put(typeHash, text);
-  return { hash };
-}

packages/cli-workflow/src/schemas.ts

@@ -2,13 +2,10 @@ import type { Hash, Store } from "@uncaged/json-cas";
 import { putSchema } from "@uncaged/json-cas";
 import { START_NODE_SCHEMA, STEP_NODE_SCHEMA, WORKFLOW_SCHEMA } from "@uncaged/workflow-protocol";
 
-export const TEXT_SCHEMA = { type: "string" as const };
-
 export type UwfSchemaHashes = {
   workflow: Hash;
   startNode: Hash;
   stepNode: Hash;
-  text: Hash;
 };
 
 /**
@@ -16,11 +13,10 @@ export type UwfSchemaHashes = {
  * Idempotent: safe to call on every CLI invocation.
  */
 export async function registerUwfSchemas(store: Store): Promise<UwfSchemaHashes> {
-  const [workflow, startNode, stepNode, text] = await Promise.all([
+  const [workflow, startNode, stepNode] = await Promise.all([
     putSchema(store, WORKFLOW_SCHEMA),
     putSchema(store, START_NODE_SCHEMA),
     putSchema(store, STEP_NODE_SCHEMA),
-    putSchema(store, TEXT_SCHEMA),
   ]);
-  return { workflow, startNode, stepNode, text };
+  return { workflow, startNode, stepNode };
 }

packages/workflow-agent-kit/src/run.ts

@@ -3,10 +3,9 @@ import type { CasRef, StepNodePayload, ThreadId } from "@uncaged/workflow-protoc
 import { config as loadDotenv } from "dotenv";
 import { buildOutputFormatInstruction } from "./build-output-format-instruction.js";
 import { buildContextWithMeta } from "./context.js";
-import { extract } from "./extract.js";
 import { tryFrontmatterFastPath } from "./frontmatter.js";
 import type { AgentStore } from "./storage.js";
-import { getEnvPath, loadWorkflowConfig, resolveStorageRoot } from "./storage.js";
+import { getEnvPath, resolveStorageRoot } from "./storage.js";
 import type { AgentContext, AgentOptions, AgentRunResult } from "./types.js";
 
 function fail(message: string): never {
@@ -73,24 +72,19 @@ async function runAgent(options: AgentOptions, ctx: AgentContext): Promise<Agent
 async function extractOutput(
   rawOutput: string,
   outputSchema: CasRef,
-  storageRoot: string,
   ctx: Awaited<ReturnType<typeof buildContextWithMeta>>,
 ): Promise<CasRef> {
-  const fastPath = await runWithMessage("frontmatter fast path", () =>
-    tryFrontmatterFastPath(rawOutput, outputSchema, ctx.meta.store),
-  ).catch(() => null);
+  const fastPath = await tryFrontmatterFastPath(rawOutput, outputSchema, ctx.meta.store);
 
   if (fastPath !== null) {
     return fastPath.outputHash;
   }
 
-  const config = await runWithMessage("failed to load config", () =>
-    loadWorkflowConfig(storageRoot),
+  fail(
+    "Agent output does not contain valid YAML frontmatter matching the role schema.\n" +
+      "The agent must output a YAML frontmatter block (--- delimited) as the first thing in its response.\n" +
+      `Raw output (first 500 chars): ${rawOutput.slice(0, 500)}`,
   );
-  const extracted = await runWithMessage("extract failed", () =>
-    extract(rawOutput, outputSchema, config),
-  );
-  return extracted.hash;
 }
 
 async function persistStep(options: {
@@ -136,12 +130,7 @@ export function createAgent(options: AgentOptions): () => Promise<void> {
     }
 
     const agentResult = await runAgent(options, ctx);
-    const outputHash = await extractOutput(
-      agentResult.output,
-      roleDef.frontmatter,
-      storageRoot,
-      ctx,
-    );
+    const outputHash = await extractOutput(agentResult.output, roleDef.frontmatter, ctx);
     const stepHash = await persistStep({
       ctx,
       outputHash,

packages/workflow-util/src/cli-reference.ts

@@ -46,8 +46,6 @@ uwf cas get <hash>                # read a CAS node (type + payload)
             [--timestamp]         # include timestamp in output
 uwf cas put <type-hash> <data>    # store a node, print its hash
                                   # <data>: JSON file path or inline JSON string
-uwf cas put-text <text>           # store a plain text string, print its hash
-                                  # shortcut for put with the built-in text schema
 uwf cas has <hash>                # check if a hash exists
 uwf cas refs <hash>               # list direct CAS references from a node
 uwf cas walk <hash>               # recursive traversal from a node