create-safest-tools 0.6.1 → 0.7.0

package/template/console/workflows/PlaybookFields.tsx

@@ -0,0 +1,109 @@
+import type { JsonObject, JsonValue } from "../../src/workflow-platform-types";
+import type { PlaybookGuide } from "../../shared/playbooks";
+import type { PlaybookResources } from "../../shared/playbook-resources";
+import { validateJsonSchemaValue } from "../../src/workflow-expressions";
+import { readable } from "../lib/format";
+import { noticeTemplateVariables } from "../../shared/notice-inputs";
+
+export const outcomeChoices = [
+  { code: "no_violation_found", label: "No policy violation established" },
+  { code: "violation_found", label: "Policy violation confirmed" },
+  { code: "insufficient_information", label: "Insufficient information" },
+  { code: "out_of_scope", label: "Outside this policy" },
+];
+
+export function ChoiceList({ label, value, choices, onChange, empty }: {
+  label: string; value: string[]; choices: { code: string; label: string }[]; onChange: (values: string[]) => void; empty?: string;
+}) {
+  const options = [...choices, ...value.filter(code => !choices.some(choice => choice.code === code)).map(code => ({ code, label: `${readable(code)} (saved choice)` }))];
+  return <fieldset className="playbook-choice-list"><legend>{label}</legend>{empty ? <p className="form-help">{value.length ? "Applies to the selected choices." : empty}</p> : null}{options.map(option => <label className="playbook-check" key={option.code}><input type="checkbox" checked={value.includes(option.code)} onChange={event => onChange(event.currentTarget.checked ? [...value, option.code] : value.filter(code => code !== option.code))} /><span>{option.label}</span></label>)}</fieldset>;
+}
+
+function record(value: JsonValue | undefined): JsonObject {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+/** Values are literal action inputs. Case data is mapped separately for read capabilities. */
+export function SchemaValueField({ label, schema, value, onChange, required = false }: {
+  label: string; schema: JsonObject; value?: JsonValue; onChange: (value: JsonValue | undefined) => void; required?: boolean;
+}) {
+  const description = typeof schema.description === "string" ? schema.description : "";
+  const title = typeof schema.title === "string" ? schema.title : label;
+  if (schema.type === "object" && schema.properties) {
+    const properties = record(schema.properties), current = record(value);
+    return <fieldset className="playbook-choice-list"><legend>{title}{required ? " (required)" : ""}</legend>{description ? <p>{description}</p> : null}{Object.entries(properties).map(([key, child]) => <SchemaValueField key={key} label={`${title} / ${readable(key)}`} schema={record(child)} value={current[key]} required={Array.isArray(schema.required) && schema.required.includes(key)} onChange={next => { const changed = { ...current }; if (next === undefined) delete changed[key]; else changed[key] = next; onChange(changed); }} />)}</fieldset>;
+  }
+  const enumValues = Array.isArray(schema.enum) ? schema.enum.filter(item => ["string", "number", "boolean"].includes(typeof item)) : null;
+  let field;
+  if (enumValues || schema.type === "boolean") {
+    const options = enumValues ?? [true, false];
+    field = <select required={required} value={value === undefined ? "" : JSON.stringify(value)} onChange={event => onChange(event.currentTarget.value ? JSON.parse(event.currentTarget.value) as JsonValue : undefined)}><option value="">Choose a value</option>{options.map(item => <option key={JSON.stringify(item)} value={JSON.stringify(item)}>{typeof item === "boolean" ? item ? "Yes" : "No" : readable(String(item))}</option>)}</select>;
+  } else if (schema.type === "number" || schema.type === "integer") {
+    field = <input type="number" required={required} step={schema.type === "integer" ? 1 : "any"} min={typeof schema.minimum === "number" ? schema.minimum : undefined} max={typeof schema.maximum === "number" ? schema.maximum : undefined} value={typeof value === "number" ? value : ""} onChange={event => onChange(event.currentTarget.value === "" ? undefined : Number(event.currentTarget.value))} />;
+  } else if (schema.type === "string" || !schema.type) {
+    field = <textarea required={required} rows={2} maxLength={typeof schema.maxLength === "number" ? schema.maxLength : 10000} value={typeof value === "string" ? value : ""} onChange={event => onChange(event.currentTarget.value === "" && !required ? undefined : event.currentTarget.value)} />;
+  } else {
+    field = <textarea required={required} className="code-input" spellCheck={false} value={value === undefined ? "" : typeof value === "string" ? value : JSON.stringify(value, null, 2)} onChange={event => { try { onChange(JSON.parse(event.currentTarget.value) as JsonValue); } catch { onChange(event.currentTarget.value); } }} />;
+  }
+  return <label>{title}{required ? " (required)" : ""}{field}{description ? <small>{description}</small> : null}{schema.type === "array" || schema.type === "object" ? <small>Enter JSON matching this capability. Values are checked before saving.</small> : null}</label>;
+}
+
+export function validateGuideInputs(guide: PlaybookGuide, resources: PlaybookResources | null): void {
+  if (guide.rollout === "automate") throw new Error("Choose Observe or Assist in Rollout. The current investigator requires human review for every decision.");
+  for (const notice of guide.outcomes.notices) {
+    const template = resources?.notices.find(item => item.id === notice.template_version_id);
+    if (!template) continue;
+    for (const name of noticeTemplateVariables(template.body)) {
+      const value = notice.input_mapping?.[name];
+      if (value === undefined || value === "" || (value && typeof value === "object" && !Array.isArray(value) && value.$literal === "")) throw new Error(`Add ${readable(name)} for the ${notice.audience === "reporter" ? "reporter" : "affected person"} notice in Outcomes.`);
+    }
+  }
+  for (const action of guide.outcomes.actions) {
+    const capability = resources?.capabilities.find(item => item.versionId === action.component_version_id);
+    if (!capability) continue; // Published dependency checks still enforce availability.
+    const issues = validateJsonSchemaValue(action.payload, capability.inputSchema);
+    if (issues.length) throw new Error(`${capability.name}: check ${issues[0]!.split(":")[0]!.replace(/^\$\.?/u, "") || "action inputs"}. The value must match the capability’s required type and choices in Outcomes.`);
+  }
+  for (const evidence of guide.evidence) {
+    const capability = resources?.capabilities.find(item => item.versionId === evidence.component_version_id);
+    const required = capability && Array.isArray(capability.inputSchema.required) ? capability.inputSchema.required : [];
+    for (const field of required) if (typeof field === "string" && !(field in evidence.input_mapping)) throw new Error(`${evidence.label}: choose a value for ${readable(field)} in Evidence.`);
+    for (const [field, mapping] of Object.entries(evidence.input_mapping)) {
+      if (!mapping || typeof mapping !== "object" || Array.isArray(mapping) || !("$literal" in mapping)) continue;
+      const schema = record(record(capability?.inputSchema.properties)[field]);
+      if (validateJsonSchemaValue(mapping.$literal!, schema).length) throw new Error(`${evidence.label}: check the fixed value for ${readable(field)} in Evidence.`);
+    }
+  }
+}
+
+export function NoticeInputs({ body, mapping, onChange }: { body: string; mapping: JsonObject; onChange: (mapping: JsonObject) => void }) {
+  const sources = [{ path: "$.report.public_reference", label: "Case reference" }, { path: "$.steps.decision.decisionCode", label: "Recorded decision code" }];
+  const preview = body.replace(/\{\{\s*([A-Za-z0-9_-]{1,80})\s*\}\}/gu, (_match, name: string) => {
+    const value = mapping[name];
+    if (value && typeof value === "object" && !Array.isArray(value) && "$literal" in value) return String(value.$literal ?? "");
+    return `[${sources.find(source => source.path === value)?.label ?? (value === undefined ? `Add ${readable(name)}` : "Saved expression")}]`;
+  });
+  return <div>{noticeTemplateVariables(body).map(name => {
+    const value = mapping[name];
+    const literal = value && typeof value === "object" && !Array.isArray(value) && "$literal" in value;
+    const saved = value !== undefined && !literal && !sources.some(source => source.path === value);
+    const update = (next: JsonValue) => onChange({ ...mapping, [name]: next });
+    return <div className="playbook-input-field" key={name}><label>Notice {readable(name)}<select required value={literal ? "fixed" : saved ? "saved" : typeof value === "string" ? value : ""} onChange={event => update(event.currentTarget.value === "fixed" ? { $literal: "" } : event.currentTarget.value)}><option value="">Choose notice content</option><option value="fixed">Write participant-facing text</option>{sources.map(source => <option key={source.path} value={source.path}>{source.label}</option>)}{saved ? <option value="saved">Saved expression</option> : null}</select></label>{literal ? <label>Text for {readable(name)}<textarea required rows={3} maxLength={4000} value={String(record(value).$literal ?? "")} onChange={event => update({ $literal: event.currentTarget.value })} /></label> : saved ? <pre tabIndex={0}>{JSON.stringify(value, null, 2)}</pre> : null}</div>;
+  })}<p className="form-help">Write for this participant. Internal review rationale and other participants’ identities are not inserted automatically.</p><strong>Notice preview</strong><blockquote className="playbook-notice-preview">{preview || "Choose a published template to preview its notice."}</blockquote></div>;
+}
+
+export function CaseInputField({ name, schema, value, required, capability, resources, onChange }: {
+  name: string; schema: JsonObject; value?: JsonValue; required: boolean;
+  capability: PlaybookResources["capabilities"][number]; resources: PlaybookResources | null;
+  onChange: (value: JsonValue | undefined) => void;
+}) {
+  const allowed = capability.allowedFields.map(path => path.replace(/^\$\./u, ""));
+  const sources = [...(resources?.scope.fields ?? [])];
+  for (const path of allowed) if (!sources.some(source => source.path === path)) sources.push({ path, label: readable(path.replaceAll(".", " / ")) });
+  const options = sources.filter(source => allowed.some(path => path === source.path || source.path.startsWith(`${path}.`)));
+  const literal = Boolean(value && typeof value === "object" && !Array.isArray(value) && "$literal" in value);
+  const advanced = value !== undefined && !literal && !(typeof value === "string" && value.startsWith("$."));
+  const selected = literal ? "fixed" : advanced ? "advanced" : typeof value === "string" ? value : "";
+  const label = typeof schema.title === "string" ? schema.title : readable(name);
+  return <div className="playbook-input-field"><label>Value for {label}{required ? " (required)" : ""}<select required={required} value={selected} onChange={event => onChange(event.currentTarget.value === "fixed" ? { $literal: schema.type === "boolean" ? false : schema.type === "number" || schema.type === "integer" ? 0 : "" } : event.currentTarget.value || undefined)}><option value="">Choose case data</option>{options.map(source => <option key={source.path} value={`$.${source.path}`}>{source.label}</option>)}{typeof value === "string" && value.startsWith("$.") && !options.some(source => `$.${source.path}` === value) ? <option value={value}>Saved source · {value}</option> : null}<option value="fixed">A fixed value for every case</option>{advanced ? <option value="advanced">Saved advanced expression</option> : null}</select></label>{literal ? <SchemaValueField label={`Fixed ${label}`} schema={schema} required={required} value={record(value).$literal} onChange={next => onChange(next === undefined ? undefined : { $literal: next })} /> : advanced ? <pre tabIndex={0} aria-label={`Saved ${label} expression`}>{JSON.stringify(value, null, 2)}</pre> : null}{advanced ? <small>The saved expression is preserved. Use Workflow for advanced changes, or deliberately choose a replacement above.</small> : null}</div>;
+}

package/template/console/workflows/PlaybookGuideEditor.tsx

@@ -0,0 +1,125 @@
+import { useEffect, useState } from "react";
+import type { JsonObject } from "../../src/workflow-platform-types";
+import type { PlaybookGuide } from "../../shared/playbooks";
+import type { PlaybookResources } from "../../shared/playbook-resources";
+import { errorMessage, requestJson } from "../lib/http";
+import { readable } from "../lib/format";
+import { CaseInputField, ChoiceList, NoticeInputs, outcomeChoices, SchemaValueField } from "./PlaybookFields";
+
+export const guideSteps = ["Situation", "Evidence", "Investigation", "Review", "Outcomes", "Rollout"];
+
+export function usePlaybookResources(enabled: boolean) {
+  const [resources, setResources] = useState<PlaybookResources | null>(null);
+  const [error, setError] = useState("");
+  const [attempt, setAttempt] = useState(0);
+  useEffect(() => {
+    if (!enabled) return;
+    let active = true;
+    setError("");
+    void requestJson<PlaybookResources>("/v1/admin/playbook-resources").then(value => { if (active) setResources(value); }).catch(cause => { if (active) setError(errorMessage(cause, "The available policies and connections could not be loaded.")); });
+    return () => { active = false; };
+  }, [enabled, attempt]);
+  return { resources, error, reload: () => setAttempt(value => value + 1) };
+}
+
+function ListInput({ label, value, onChange, hint }: { label: string; value: string[]; onChange: (value: string[]) => void; hint?: string }) {
+  const [draft, setDraft] = useState(value.join(", "));
+  const serialized = value.join(", ");
+  const parse = (text: string) => [...new Set(text.split(",").map(value => value.trim()).filter(Boolean))];
+  useEffect(() => { if (parse(draft).join(", ") !== serialized) setDraft(serialized); }, [serialized]);
+  return <label>{label}<input value={draft} maxLength={2000} onChange={event => { setDraft(event.currentTarget.value); onChange(parse(event.currentTarget.value)); }} /><small>{hint || "Separate each choice with a comma."}</small></label>;
+}
+
+export function PlaybookGuideEditor({ value, onChange, step, resources, disabled = false }: {
+  value: PlaybookGuide; onChange: (guide: PlaybookGuide) => void; step: number; resources: PlaybookResources | null; disabled?: boolean;
+}) {
+  const update = (change: (guide: PlaybookGuide) => void) => { const next = structuredClone(value); change(next); onChange(next); };
+  const reads = resources?.capabilities.filter(capability => capability.effect === "read_only") ?? [];
+  const actions = resources?.capabilities.filter(capability => capability.effect === "side_effecting") ?? [];
+  return <fieldset className="playbook-guide-fields" disabled={disabled}>
+    <legend className="sr-only">{guideSteps[step]}</legend>
+    {step === 0 ? <>
+      <div className="playbook-step-intro"><span className="eyebrow">01 / Situation</span><h3>What should Safest help resolve?</h3><p>Describe the situation, then connect it to the policy your team has published.</p></div>
+      <label>Situation<textarea required maxLength={2000} value={value.summary} onChange={event => update(guide => { guide.summary = event.currentTarget.value; })} /></label>
+      <div className="form-grid">
+        <ChoiceList label="Reported concerns" value={value.scope.reason_codes} choices={resources?.scope.reasons ?? []} onChange={codes => update(guide => { guide.scope.reason_codes = codes; })} empty="Every report reason is included until you select specific concerns." />
+        <ChoiceList label="What can be reported?" value={value.scope.target_types} choices={(resources?.scope.targetTypes ?? []).map(code => ({ code, label: readable(code) }))} onChange={codes => update(guide => { guide.scope.target_types = codes; })} empty="Every target type is included until you select specific types." />
+        <label>Published policy<select required value={value.policy_version_id} onChange={event => update(guide => {
+          guide.policy_version_id = event.currentTarget.value;
+          const policy = resources?.policies.find(policy => policy.id === guide.policy_version_id);
+          if (policy?.rules[0]) guide.policy_code = policy.rules[0].code;
+        })}><option value="">Choose a policy</option>{!resources?.policies.some(policy => policy.id === value.policy_version_id) && value.policy_version_id ? <option value={value.policy_version_id}>Saved policy · {value.policy_version_id}</option> : null}{resources?.policies.map(policy => <option key={policy.id} value={policy.id}>{policy.name} · v{policy.version}</option>)}</select></label>
+        <label>Policy rule<select required value={value.policy_code} onChange={event => update(guide => { guide.policy_code = event.currentTarget.value; })}>
+          <option value="">Choose a rule</option>{!resources?.policies.find(policy => policy.id === value.policy_version_id)?.rules.some(rule => rule.code === value.policy_code) && value.policy_code ? <option value={value.policy_code}>{value.policy_code}</option> : null}
+          {resources?.policies.find(policy => policy.id === value.policy_version_id)?.rules.map(rule => <option value={rule.code} key={rule.code}>{rule.title}</option>)}
+        </select></label>
+      </div>
+      <label>Policy guidance or imported policy<textarea required rows={7} maxLength={20000} value={value.policy_text} onChange={event => update(guide => { guide.policy_text = event.currentTarget.value; })} /><small>Paste the relevant policy and exceptions. This guidance accompanies the pinned policy; review it before publication.</small></label>
+      {resources?.policies.find(policy => policy.id === value.policy_version_id)?.rules.find(rule => rule.code === value.policy_code)?.description ? <blockquote className="playbook-notice-preview">{resources.policies.find(policy => policy.id === value.policy_version_id)?.rules.find(rule => rule.code === value.policy_code)?.description}</blockquote> : null}
+      <details><summary>Custom intake identifiers</summary><p>Use these only when your customer integration supplies values outside the published forms.</p><ListInput label="Report reason codes" value={value.scope.reason_codes} onChange={codes => update(guide => { guide.scope.reason_codes = codes; })} /><ListInput label="Target type codes" value={value.scope.target_types} onChange={codes => update(guide => { guide.scope.target_types = codes; })} /></details>
+    </> : null}
+    {step === 1 ? <>
+      <div className="playbook-step-intro"><span className="eyebrow">02 / Evidence</span><h3>Give Safest the context it needs.</h3><p>Case answers and verified intake context are already available. Select additional read capabilities from your connected product.</p></div>
+      {!reads.length ? <div className="playbook-callout"><strong>No additional read capabilities are available yet.</strong><p>You can start with report evidence and human review. Add a read capability in Connections when your product can supply more context.</p></div> : null}
+      {reads.map(capability => {
+        const selected = value.evidence.find(evidence => evidence.component_version_id === capability.versionId);
+        const fields = capability.inputSchema.properties && typeof capability.inputSchema.properties === "object" && !Array.isArray(capability.inputSchema.properties) ? Object.keys(capability.inputSchema.properties) : [];
+        return <article className={`playbook-capability${selected ? " selected" : ""}`} key={capability.id}>
+          <label className="playbook-check"><input type="checkbox" checked={Boolean(selected)} disabled={!capability.available && !selected} onChange={event => update(guide => {
+            if (!event.currentTarget.checked) guide.evidence = guide.evidence.filter(evidence => evidence.component_version_id !== capability.versionId);
+            else guide.evidence.push({ id: `read-${guide.evidence.length}-${capability.id.replace(/[^a-z0-9]/giu, "").slice(0, 36)}`, label: capability.name, component_version_id: capability.versionId, required: true, input_mapping: {} });
+          })} /><span><strong>{capability.name}</strong><small>{capability.description || "Read additional case context."}</small></span><span className="badge">{capability.available ? "Read only" : "Needs setup"}</span></label>
+          <p className="playbook-source">Source: {capability.connectionName || "Workspace capability"}</p>
+          {selected ? <div className="playbook-capability-options"><label className="playbook-check"><input type="checkbox" checked={selected.required} onChange={event => update(guide => { guide.evidence.find(evidence => evidence.id === selected.id)!.required = event.currentTarget.checked; })} />Required before reaching a decision</label>
+            <p className="muted">{selected.required ? "If unavailable, the case returns to the review team without an outcome." : "Safest can continue with the missing context recorded."}</p>
+            {fields.map(field => <CaseInputField key={field} name={field} schema={(capability.inputSchema.properties as JsonObject)[field] as JsonObject} required={Array.isArray(capability.inputSchema.required) && capability.inputSchema.required.includes(field)} value={selected.input_mapping[field]} capability={capability} resources={resources} onChange={next => update(guide => {
+              const mapping = guide.evidence.find(evidence => evidence.id === selected.id)!.input_mapping;
+              if (next === undefined) delete mapping[field]; else mapping[field] = next;
+            })} />)}
+          </div> : null}
+        </article>;
+      })}
+      {value.evidence.filter(evidence => !reads.some(capability => capability.versionId === evidence.component_version_id)).map(evidence => <div className="playbook-callout" key={evidence.id}><strong>{evidence.label} · saved version unavailable in this catalogue</strong><p>The pinned version is preserved. Check its connection or remove it deliberately.</p><button className="secondary" type="button" onClick={() => update(guide => { guide.evidence = guide.evidence.filter(item => item.id !== evidence.id); })}>Remove {evidence.label}</button></div>)}
+    </> : null}
+    {step === 2 ? <>
+      <div className="playbook-step-intro"><span className="eyebrow">03 / Investigation</span><h3>Define how Safest should investigate.</h3><p>The investigator gathers evidence and prepares an explained recommendation. The playbook controls its authority.</p></div>
+      <label className="playbook-check"><input type="checkbox" checked={value.investigation.enabled} onChange={event => update(guide => { guide.investigation.enabled = event.currentTarget.checked; })} />Use a case investigator</label>
+      {value.investigation.enabled ? <>
+        <label>Investigator<select required value={value.investigation.agent_version_id} onChange={event => update(guide => { guide.investigation.agent_version_id = event.currentTarget.value; })}><option value="">Choose an approved investigator</option>{value.investigation.agent_version_id && !resources?.agents.some(agent => agent.versionId === value.investigation.agent_version_id) ? <option value={value.investigation.agent_version_id}>Saved investigator · {value.investigation.agent_version_id}</option> : null}{resources?.agents.map(agent => <option key={agent.versionId} value={agent.versionId}>{agent.name} · Workers AI</option>)}</select></label>
+        {!resources?.agents.length ? <p className="playbook-callout">An administrator needs to configure an investigator with an approved Workers AI model before this can be published with investigation enabled.</p> : null}
+        <p className="form-help">The investigator can read approved evidence tools and prepare a cited proposal. Your team reviews the result before a decision or action.</p><label>Investigation instructions<textarea rows={6} maxLength={8000} value={value.investigation.instructions} onChange={event => update(guide => { guide.investigation.instructions = event.currentTarget.value; })} /></label>
+        <label>Maximum investigation steps<input type="number" required min={2} max={20} value={value.investigation.max_steps} onChange={event => update(guide => { guide.investigation.max_steps = Number(event.currentTarget.value); })} /><small>Unresolved questions remain visible when the investigator reaches this limit.</small></label>
+      </> : <div className="playbook-callout"><strong>Your team leads the investigation.</strong><p>Safest gathers the selected evidence and brings it to a reviewer.</p></div>}
+    </> : null}
+    {step === 3 ? <>
+      <div className="playbook-step-intro"><span className="eyebrow">04 / Review</span><h3>Make human responsibility explicit.</h3><p>Assist sends every decision to a person. This team also receives missing evidence and failed execution.</p></div>
+      <label>Review team<select required value={value.review.queue_id} onChange={event => update(guide => { guide.review.queue_id = event.currentTarget.value; })}><option value="">Choose a team queue</option>{value.review.queue_id && !resources?.queues.some(queue => queue.id === value.review.queue_id) ? <option value={value.review.queue_id}>Saved queue · {value.review.queue_id}</option> : null}{resources?.queues.map(queue => <option value={queue.id} key={queue.id}>{queue.name}</option>)}</select></label>
+      <label>Reviewer instructions<textarea rows={6} maxLength={8000} value={value.review.instructions} onChange={event => update(guide => { guide.review.instructions = event.currentTarget.value; })} /></label>
+      <label>Escalate an unanswered review after (hours)<input required type="number" min={1} max={720} value={value.review.timeout_seconds / 3600} onChange={event => update(guide => { guide.review.timeout_seconds = Number(event.currentTarget.value) * 3600; })} /><small>A missed deadline returns the case to the team. It never becomes an approved decision.</small></label>
+    </> : null}
+    {step === 4 ? <>
+      <div className="playbook-step-intro"><span className="eyebrow">05 / Outcomes</span><h3>Connect a decision to what happens next.</h3><p>Choose permitted outcomes, customer actions and separate participant notices. Safest waits for action confirmation before sending these notices.</p></div>
+      <ChoiceList label="Permitted outcomes" value={value.outcomes.decision_codes} choices={outcomeChoices} onChange={codes => update(guide => { guide.outcomes.decision_codes = codes; guide.outcomes.delegated_decision_codes = guide.outcomes.delegated_decision_codes.filter(code => codes.includes(code)); })} />
+      <details><summary>Custom decision identifiers</summary><ListInput label="Permitted decision codes" value={value.outcomes.decision_codes} onChange={codes => update(guide => { guide.outcomes.decision_codes = codes; })} hint="Use stable codes from your customer integration for additional outcomes." /></details>
+      {value.outcomes.actions.map((action, index) => <article className="playbook-capability" key={index}><div className="form-grid">
+        <label>When the decision is<select required value={action.decision_code} onChange={event => update(guide => { guide.outcomes.actions[index]!.decision_code = event.currentTarget.value; })}>{value.outcomes.decision_codes.map(code => <option key={code} value={code}>{outcomeChoices.find(choice => choice.code === code)?.label ?? readable(code)}</option>)}</select></label>
+        <label>Customer action<select required value={action.component_version_id} onChange={event => update(guide => { const capability = actions.find(capability => capability.versionId === event.currentTarget.value); guide.outcomes.actions[index]!.component_version_id = event.currentTarget.value; guide.outcomes.actions[index]!.approval = capability?.approval ?? "human"; })}><option value="">Choose an action capability</option>{actions.map(capability => <option key={capability.versionId} value={capability.versionId} disabled={!capability.available}>{capability.name}{!capability.available ? " · Needs setup" : ""}</option>)}</select></label>
+        <label>Action name in your product<input required maxLength={100} value={action.action_code} onChange={event => update(guide => { guide.outcomes.actions[index]!.action_code = event.currentTarget.value; })} /></label>
+      </div><p className="form-help">Use the action name accepted by your customer integration, for example hide_message. The target comes from this case; the values below are fixed for this action.</p>
+      {actions.find(capability => capability.versionId === action.component_version_id) ? <SchemaValueField label="Action inputs" schema={actions.find(capability => capability.versionId === action.component_version_id)!.inputSchema} value={action.payload} onChange={payload => update(guide => { guide.outcomes.actions[index]!.payload = (payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {}) as JsonObject; })} /> : null}
+      <p>{action.approval === "human" ? "A person must approve this customer action." : "This capability needs delegated authority, which is unavailable for new guided playbooks. Choose a capability with human approval."}</p><button className="text-button" type="button" onClick={() => update(guide => { guide.outcomes.actions.splice(index, 1); })}>Remove action</button></article>)}
+      <button className="secondary" type="button" disabled={!actions.length || !value.outcomes.decision_codes.length || value.outcomes.actions.length >= 8} onClick={() => update(guide => { guide.outcomes.actions.push({ decision_code: guide.outcomes.decision_codes[0]!, action_code: "", component_version_id: "", approval: "human", payload: {} }); })}>Add customer action</button>
+      {!actions.length ? <p className="muted">Connect an action capability when your product is ready to apply decisions.</p> : null}
+      <div className="form-grid">{(["reporter", "affected_user"] as const).map(audience => {
+        const selected = value.outcomes.notices.find(notice => notice.audience === audience);
+        const options = resources?.notices.filter(notice => notice.audience === audience) ?? [];
+        return <div key={audience}><label>{audience === "reporter" ? "Reporter outcome notice" : "Affected user notice"}<select value={selected?.template_version_id ?? ""} onChange={event => update(guide => { guide.outcomes.notices = guide.outcomes.notices.filter(notice => notice.audience !== audience); if (event.currentTarget.value) guide.outcomes.notices.push({ audience, template_version_id: event.currentTarget.value }); })}><option value="">No automatic notice</option>{options.map(notice => <option key={notice.id} value={notice.id}>{notice.name} · v{notice.version}</option>)}</select></label>{selected ? <><NoticeInputs body={options.find(notice => notice.id === selected.template_version_id)?.body ?? ""} mapping={selected.input_mapping ?? {}} onChange={mapping => update(guide => { guide.outcomes.notices.find(notice => notice.audience === audience)!.input_mapping = mapping; })} /></> : null}</div>;
+      })}</div>
+    </> : null}
+    {step === 5 ? <>
+      <div className="playbook-step-intro"><span className="eyebrow">06 / Rollout</span><h3>Choose how much responsibility to delegate.</h3><p>Run your examples before publishing. Activating a published version affects new cases; active cases keep their version.</p></div>
+      {([{ value: "observe", title: "Observe", detail: "Gather context and investigate without decisions, customer actions or participant notices." }, { value: "assist", title: "Assist", detail: "Prepare the case for a person. Decisions and customer actions require approval." }] as const).map(mode => <label className="template-choice" key={mode.value}><input type="radio" name="playbook-rollout" checked={value.rollout === mode.value} onChange={() => update(guide => { guide.rollout = mode.value; guide.outcomes.delegated_decision_codes = []; })} /><span><strong>{mode.title}</strong><small>{mode.detail}</small></span></label>)}
+      <div className="playbook-callout"><strong>Every investigator decision currently requires human review.</strong><p>The investigator uses Think for persistent investigation and your configured Workers AI model for reasoning. Delegated decisions are not available in new guided playbooks.</p>{value.rollout === "automate" ? <p>This saved definition contains delegated outcomes. They are preserved for inspection, but the current investigator always returns to a person. Select Assist before republishing a guided revision.</p> : null}</div>
+    </> : null}
+  </fieldset>;
+}

package/template/console/workflows/PlaybookHistory.tsx

@@ -0,0 +1,106 @@
+import { useEffect, useRef, useState, type FormEvent } from "react";
+import { readable } from "../lib/format";
+import { errorMessage, mutationHeaders, requestJson } from "../lib/http";
+import { dispatchOpenReport } from "../reports/events";
+import { announceWorkflowChanged } from "./events";
+import type { QueueListItem, WorkflowVersionResponse, WorkflowVersionSummary } from "./types";
+
+export interface PlaybookRun {
+  id: string; reportId: string; publicReference: string; version: number; state: string;
+  runKind: string; authorityMode: string; currentNodeId: string | null; currentNodeName: string | null; errorCode: string | null;
+  stepCount: number; openTaskCount: number; createdAt: string;
+}
+export function PlaybookRuns({ workflowId, onOpenCase }: { workflowId: string; onOpenCase: () => void }) {
+  const [runs, setRuns] = useState<PlaybookRun[]>([]);
+  const [state, setState] = useState("");
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState("");
+  const [reload, setReload] = useState(0);
+  useEffect(() => {
+    let active = true; setLoading(true); setError("");
+    void requestJson<{ runs: PlaybookRun[] }>(`/v1/admin/workflow-runs?workflow_id=${workflowId}&limit=100${state ? `&state=${state}` : ""}`).then(result => { if (active) setRuns(result.runs); }).catch(cause => { if (active) setError(errorMessage(cause, "Runs could not be loaded.")); }).finally(() => { if (active) setLoading(false); });
+    return () => { active = false; };
+  }, [workflowId, state, reload]);
+  return <section className="playbook-lifecycle-panel" aria-label="Playbook runs"><div className="playbook-panel-heading"><div><p className="eyebrow">Live case history</p><h3>See where cases need help.</h3><p>Up to 100 recent runs in queues you can access. Each case keeps the published version it started with.</p></div><button type="button" className="secondary" disabled={loading} onClick={() => setReload(value => value + 1)}>Refresh runs</button></div>
+    <label className="playbook-run-filter">Run state<select value={state} onChange={event => setState(event.currentTarget.value)}><option value="">All states</option>{["running", "waiting", "paused", "succeeded", "failed", "repair_required", "dispatch_pending", "terminated"].map(value => <option key={value} value={value}>{readable(value)}</option>)}</select></label>
+    {loading ? <p role="status">Loading case runs…</p> : error ? <p className="error" role="alert">{error}</p> : runs.length ? <div className="playbook-run-list">{runs.map(run => <article key={run.id}><div className="playbook-panel-heading"><div><strong>{run.publicReference || "Case"}</strong><p>Version {run.version} · {run.runKind === "shadow" ? "Observe" : readable(run.authorityMode)} · {new Date(run.createdAt).toLocaleString()}</p></div><span className="badge">{readable(run.state)}</span></div><p>{run.openTaskCount ? `${run.openTaskCount} task${run.openTaskCount === 1 ? "" : "s"} waiting for a person.` : `${run.stepCount} steps recorded.`}{run.currentNodeId ? ` Current step: ${run.currentNodeName ?? readable(run.currentNodeId)}.` : ""}</p>{run.errorCode ? <p className="error">Needs attention: {readable(run.errorCode)}.</p> : null}<button type="button" className="secondary" onClick={() => { onOpenCase(); window.location.hash = "reports"; requestAnimationFrame(() => dispatchOpenReport(run.reportId)); }}>Open case {run.publicReference || "details"}</button></article>)}</div> : <div className="playbook-callout"><strong>{state ? "No runs in this state" : "No cases have used this playbook yet"}</strong><p>{state ? "Choose another state or refresh after work progresses." : "Activate a published version for a queue, then submit a test case through your reporting channel. Simulated examples appear in Test."}</p></div>}
+  </section>;
+}
+
+type VersionDetail = WorkflowVersionResponse["version"] & { testEvidence?: { example_test_run_ids?: string[]; test_run_id?: string; examples?: { test_run_id: string; name: string; revision: number }[] }; artifactStatus?: string };
+type VersionDiff = { againstVersionId: string | null; nodes: { added: string[]; removed: string[]; changed: string[] }; guide: string[]; edgesChanged: boolean; authorityMode: { from: string | null; to: string } };
+type Pin = { id: string; mode: "primary" | "shadow"; workflowVersionId: string; workflowName: string; version: number; deactivatedAt: string | null };
+export function PlaybookVersions({ workflowId, epoch, queues, defaultQueueId, canActivate, disabled, onPending, onActivated }: {
+  workflowId: string; epoch: number; queues: QueueListItem[]; defaultQueueId: string; canActivate: boolean; disabled: boolean;
+  onPending: (pending: boolean) => void; onActivated: (message: string) => void;
+}) {
+  const [versions, setVersions] = useState<WorkflowVersionSummary[]>([]);
+  const [selected, setSelected] = useState("");
+  const [detail, setDetail] = useState<VersionDetail | null>(null);
+  const [diff, setDiff] = useState<VersionDiff | null>(null);
+  const [queueId, setQueueId] = useState(defaultQueueId);
+  const [pins, setPins] = useState<Pin[] | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState("");
+  const [pinError, setPinError] = useState("");
+  const [notice, setNotice] = useState("");
+  const [evidence, setEvidence] = useState<{ name: string; record: unknown } | null>(null);
+  const [evidenceLoading, setEvidenceLoading] = useState(false);
+  const evidenceGeneration = useRef(0);
+  const [reload, setReload] = useState(0);
+  useEffect(() => () => onPending(false), [onPending]);
+  useEffect(() => {
+    let active = true; setLoading(true); setError("");
+    void requestJson<{ versions: WorkflowVersionSummary[] }>(`/v1/admin/workflows/${workflowId}/versions`).then(result => {
+      if (active) { setVersions(result.versions); setSelected(previous => result.versions.some(version => version.id === previous) ? previous : result.versions[0]?.id ?? ""); }
+    }).catch(cause => { if (active) setError(errorMessage(cause, "Version history could not be loaded.")); }).finally(() => { if (active) setLoading(false); });
+    return () => { active = false; };
+  }, [workflowId, epoch, reload]);
+  useEffect(() => {
+    setDetail(null); setDiff(null); setEvidence(null); setEvidenceLoading(false); evidenceGeneration.current += 1; if (!selected) return;
+    let active = true; setError("");
+    void Promise.all([
+      requestJson<WorkflowVersionResponse>(`/v1/admin/workflows/${workflowId}/versions/${selected}`),
+      requestJson<{ diff: VersionDiff }>(`/v1/admin/workflows/${workflowId}/versions/${selected}/diff`),
+    ]).then(([version, comparison]) => { if (active) { setDetail(version.version); setDiff(comparison.diff); } }).catch(cause => { if (active) setError(errorMessage(cause, "This version could not be opened.")); });
+    return () => { active = false; };
+  }, [workflowId, selected, reload]);
+  useEffect(() => {
+    setPins(null); setPinError(""); if (!queueId || !canActivate) return;
+    let active = true;
+    void requestJson<{ pins: Pin[] }>(`/v1/admin/queues/${queueId}/workflow-pin`).then(result => { if (active) setPins(result.pins); }).catch(cause => { if (active) setPinError(errorMessage(cause, "The current activation could not be checked.")); });
+    return () => { active = false; };
+  }, [queueId, canActivate, reload, epoch]);
+  const mode = detail?.authorityMode === "shadow" ? "shadow" : "primary";
+  const activePin = pins?.find(pin => !pin.deactivatedAt && pin.mode === mode);
+  const alreadyActive = activePin?.workflowVersionId === selected;
+  const activate = async (event: FormEvent): Promise<void> => {
+    event.preventDefault(); if (!detail || !canActivate || !queueId || !pins || alreadyActive || disabled || pending) return;
+    setPending(true); onPending(true); setError(""); setNotice("");
+    try {
+      await requestJson(`/v1/admin/queues/${queueId}/workflow-pin`, { method: "PUT", headers: mutationHeaders(), body: JSON.stringify({ workflow_version_id: selected, mode, expected_pin_id: activePin?.id ?? null, ...(activePin ? { rollback_of_pin_id: activePin.id } : {}) }) });
+      const message = `Version ${detail.version} is active for new cases in ${queues.find(queue => queue.id === queueId)?.name ?? "the selected queue"}. Existing cases keep their original version.`;
+      setNotice(message);
+      setReload(value => value + 1); announceWorkflowChanged(); onActivated(message);
+    } catch (cause) { setError(errorMessage(cause, "The activation could not be saved.")); }
+    finally { setPending(false); onPending(false); }
+  };
+  const guide = detail?.graph.playbook;
+  return <section className="playbook-lifecycle-panel" aria-label="Playbook versions"><div className="playbook-panel-heading"><div><p className="eyebrow">Published history</p><h3>Change the plan with confidence.</h3><p>Published versions are immutable. Activate a previous version for new cases without rewriting cases already in progress.</p></div><button type="button" className="secondary" disabled={disabled || pending || loading} onClick={() => setReload(value => value + 1)}>Refresh versions</button></div>
+    {loading ? <p role="status">Loading versions…</p> : versions.length ? <div className="playbook-examples-layout"><nav className="playbook-example-list" aria-label="Published versions">{versions.map(version => <button type="button" key={version.id} disabled={disabled || pending} aria-current={version.id === selected ? "true" : undefined} onClick={() => { setSelected(version.id); setNotice(""); }}><strong>Version {version.version}</strong><span>{version.authorityMode === "shadow" ? "Observe" : readable(version.authorityMode)}{version.retiredAt ? " · Retired" : ""}</span><small>{new Date(version.publishedAt).toLocaleString()}</small></button>)}</nav>
+      {detail ? <div className="playbook-version-detail"><h4>Version {detail.version}</h4>{guide ? <><p>{guide.summary}</p><dl className="playbook-result-facts"><div><dt>Rollout</dt><dd>{readable(guide.rollout)}</dd></div><div><dt>Evidence capabilities</dt><dd>{guide.evidence.length}</dd></div><div><dt>Investigation</dt><dd>{guide.investigation.enabled ? "Case investigator" : "Human review"}</dd></div><div><dt>Outcome choices</dt><dd>{guide.outcomes.decision_codes.map(readable).join(", ")}</dd></div></dl><details><summary>Published policy guidance</summary><p className="playbook-notice-preview">{guide.policy_text}</p></details></> : <p>Advanced workflow with {detail.graph.nodes.length} steps.</p>}
+      {diff ? <section className="playbook-callout"><strong>{diff.againstVersionId ? `Changes from version ${versions.find(version => version.id === diff.againstVersionId)?.version ?? "previous"}` : "First published version"}</strong><p>{diff.nodes.added.length} steps added · {diff.nodes.changed.length} changed · {diff.nodes.removed.length} removed{diff.edgesChanged ? " · Flow paths changed" : ""}</p>{diff.againstVersionId && diff.guide?.length ? <p>Guide sections: {diff.guide.filter(key => key !== "schema_version").map(key => ({ summary: "Situation", policy_text: "Policy guidance", policy_version_id: "Policy version", policy_code: "Policy rule", editing_mode: "Editing mode" }[key] ?? readable(key))).join(", ")}.</p> : null}{diff.authorityMode.from !== diff.authorityMode.to && diff.authorityMode.from ? <p>Authority changed from {readable(diff.authorityMode.from)} to {readable(diff.authorityMode.to)}.</p> : null}</section> : null}
+      <p>{detail.testEvidence?.example_test_run_ids?.length ?? (detail.testEvidence?.test_run_id ? 1 : 0)} passing example records preserved with this version.</p>
+      {detail.testEvidence?.examples?.length ? <details className="playbook-published-examples"><summary>Inspect the examples used for publication</summary><p>These records preserve the inputs and results from publication, even after an example is edited or deleted.</p>{detail.testEvidence.examples.map(example => <button className="text-button" type="button" key={example.test_run_id} disabled={evidenceLoading} onClick={() => {
+        setEvidenceLoading(true); setEvidence(null); const generation = evidenceGeneration.current;
+        void requestJson<{ test_run: unknown }>(`/v1/admin/workflows/${workflowId}/test-runs/${example.test_run_id}`).then(result => { if (generation === evidenceGeneration.current) setEvidence({ name: example.name, record: result.test_run }); }).catch(cause => { if (generation === evidenceGeneration.current) setError(errorMessage(cause, "This publication example could not be loaded.")); }).finally(() => { if (generation === evidenceGeneration.current) setEvidenceLoading(false); });
+      }}>{example.name} · revision {example.revision}</button>)}{evidenceLoading ? <p role="status">Loading the saved test record…</p> : evidence ? <div><h4>{evidence.name}</h4><pre className="playbook-json-record" tabIndex={0} aria-label="Published example record">{JSON.stringify(evidence.record, null, 2)}</pre></div> : null}</details> : null}
+      <details><summary>Published workflow and verification record</summary><pre className="playbook-json-record" tabIndex={0} aria-label="Published workflow record">{JSON.stringify({ graph: detail.graph, graphDigest: detail.graphDigest, bundleDigest: detail.bundleDigest, testEvidence: detail.testEvidence }, null, 2)}</pre></details>
+      {canActivate ? <form className="playbook-activation" onSubmit={event => void activate(event)}><fieldset className="playbook-guide-fields" disabled={disabled || pending}><legend>Activate this version</legend><h4>Activate version {detail.version}</h4><label>Queue for new cases<select required value={queueId} onChange={event => setQueueId(event.currentTarget.value)}><option value="">Choose a queue</option>{queues.map(queue => <option key={queue.id} value={queue.id}>{queue.name}</option>)}</select></label>
+      <div className="playbook-callout">{pins ? <><strong>{activePin ? `Currently active: ${activePin.workflowName}, version ${activePin.version}` : "No version active in this mode"}</strong><p>{mode === "shadow" ? "Observe runs alongside the primary process and cannot enforce an outcome." : "New eligible cases will use this version as their primary process."} Existing cases keep their original version.</p></> : <p>{pinError || (queueId ? "Checking current activation…" : "Choose a queue to check its current activation.")}</p>}</div>
+      <button type="submit" className="primary" disabled={!pins || !queueId || alreadyActive || Boolean(detail.retiredAt) || detail.authorityMode === "off"}>{pending ? "Activating…" : alreadyActive ? "Active for new cases" : `Activate version ${detail.version} for new cases`}</button></fieldset></form> : null}
+      </div> : <p role="status">Loading the published version…</p>}</div> : <div className="playbook-callout"><strong>No published versions yet</strong><p>Save your guide and pass the examples, then publish the draft. Publication alone does not activate it.</p></div>}
+    <p className="error" role="alert">{error}</p><p role="status">{notice}</p>
+  </section>;
+}

package/template/console/workflows/WorkflowDialogs.tsx

@@ -1,6 +1,7 @@
 import { CreateWorkflowDialog } from "./CreateWorkflowDialog";
 import { WorkflowStudio } from "./WorkflowStudio";
+import { CreatePlaybookDialog } from "./CreatePlaybookDialog";
 
 export function WorkflowDialogs() {
-  return <><CreateWorkflowDialog /><WorkflowStudio /></>;
+  return <><CreatePlaybookDialog /><CreateWorkflowDialog /><WorkflowStudio /></>;
 }