skillscript-runtime 0.26.5 → 0.26.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md
CHANGED
|
@@ -2,6 +2,16 @@
|
|
|
2
2
|
|
|
3
3
|
Each release carries an **Upgrade impact:** line (first in its section) so a bump's requirements are visible at a glance. Tags (closed set): **BREAKING** (a manual change is needed to keep working) · **RE-APPROVE** (secured-mode signature invalidation — skills must be re-approved before they run) · **CONFIG** (`connectors.json` / config edit needed) · **none (additive)** (no action; backward-compatible). Standard from 0.20.0 forward; the pre-0.20 transitions that need action are flagged inline below (0.14.0, 0.18.8, 0.19.0). Full walkthrough: [UPGRADING.md](UPGRADING.md).
|
|
4
4
|
|
|
5
|
+
## 0.26.6 — 2026-07-06 — help: error-handling topic correctness fix (`(fallback:)` does NOT catch a raised throw)
|
|
6
|
+
|
|
7
|
+
**Upgrade impact:** none (additive; help-content + server-instructions only). No runtime behavior change.
|
|
8
|
+
|
|
9
|
+
The 0.26.5 `error-handling` topic taught a **broken containment pattern**: its flagship Rule 2 example put a per-leg `(fallback:)` on `execute_skill` legs and claimed it prevents a gather abort. It does not — and shipping it canonicalized the exact pattern that sank the 2026-07-05 morning brief (Perry `c052581b`, verified on the deployed 0.26.5 runtime).
|
|
10
|
+
|
|
11
|
+
- **Corrected the mental model to two failure shapes → two tools.** A **MISSING VALUE** (dispatch error, `shell` spawn-fail/timeout, empty result, unresolved ref) is contained by `(fallback: "…")` / a `fallback` filter. A **RAISED THROW** (`$ json_parse` on off-shape input; `execute_skill` whose child throws — e.g. the child's output template references an unset var) is **NOT** caught by `(fallback:)` — the throw propagates past the trailer and aborts the target. A raised throw is contained by an `else:` handler, or **prevented** by a structural guard (pre-bind degraded defaults + a `contains`/shape check before the risky op).
|
|
12
|
+
- **Every prescription was gate-dogfooded on the runtime before shipping** (the whole bug was a doc that confidently prescribed an unverified mechanism): confirmed `(fallback:)` catches neither an execute_skill child-throw nor a json_parse malformed-throw; confirmed `else:` catches **both**; confirmed the structural guard degrades cleanly. **`# OnError:` was found inert** (its `fallbackSkillExecutor` is never wired in the runtime) and is therefore flagged as not-a-reliable-throw-container rather than prescribed.
|
|
13
|
+
- Rule 2 now carries the corrected worked example (a throw-proof `get-weather` child), and the quickstart + server-instructions robustness lines were corrected to the same two-shapes framing.
|
|
14
|
+
|
|
5
15
|
## 0.26.5 — 2026-07-06 — help: `error-handling` topic (containment playbook on the tool-help surface)
|
|
6
16
|
|
|
7
17
|
**Upgrade impact:** none (additive). New `help()` topic + expanded server instructions; no behavior change.
|
package/dist/help-content.d.ts
CHANGED
|
@@ -7,6 +7,6 @@ import type { Registry } from "./connectors/registry.js";
|
|
|
7
7
|
* external adopters from one place. Keep the dev-agent CLAUDE.md and
|
|
8
8
|
* docs/adopter-agent-guide.md REFERENCING this, not forking divergent copies.
|
|
9
9
|
*/
|
|
10
|
-
export declare const SKILLSCRIPT_USAGE_INSTRUCTIONS = "A Skillscript runtime is wired over MCP. Skills are compiled, approved, reusable procedures \u2014 run them, don't re-derive.\n\n**Session start:** `skill_list()` \u2192 your skills, grouped: `skills` (invoke directly) \u00B7 `receives` (push context to you) \u00B7 `headless` (cron/event-fired; maintain, don't invoke). Know them before routine work.\n\n**Routine task \u2014 if a skill fits, use it, don't re-reason:**\n- `skill_preflight({name})` \u2192 vars, returns, requires, effectful footprint, cleared-to-run. (skill_list entries already carry this contract.)\n- `execute_skill({name})` \u2192 run end-to-end.\n- `compile_skill({name})` \u2192 preview the plan, no side effects.\n\n**Repeating a routine? Capture it as a skill.** What you can script = the wired connectors, models, and allowed shell binaries from `runtime_capabilities()` \u2014 that list is your menu. When you catch yourself re-running work over any of them, author it. If something you'd need isn't wired yet, ask the operator to add it, then capture it.\n- `help({topic})` \u2192 the language (ops, frontmatter, composition, error-handling, connectors, lint-codes).\n- Draft \u2192 `lint_skill({source})` \u2192 `compile_skill({source})` \u2192 `skill_write({name, source})`.\n- **Robustness:** a fallible op (
|
|
10
|
+
export declare const SKILLSCRIPT_USAGE_INSTRUCTIONS = "A Skillscript runtime is wired over MCP. Skills are compiled, approved, reusable procedures \u2014 run them, don't re-derive.\n\n**Session start:** `skill_list()` \u2192 your skills, grouped: `skills` (invoke directly) \u00B7 `receives` (push context to you) \u00B7 `headless` (cron/event-fired; maintain, don't invoke). Know them before routine work.\n\n**Routine task \u2014 if a skill fits, use it, don't re-reason:**\n- `skill_preflight({name})` \u2192 vars, returns, requires, effectful footprint, cleared-to-run. (skill_list entries already carry this contract.)\n- `execute_skill({name})` \u2192 run end-to-end.\n- `compile_skill({name})` \u2192 preview the plan, no side effects.\n\n**Repeating a routine? Capture it as a skill.** What you can script = the wired connectors, models, and allowed shell binaries from `runtime_capabilities()` \u2014 that list is your menu. When you catch yourself re-running work over any of them, author it. If something you'd need isn't wired yet, ask the operator to add it, then capture it.\n- `help({topic})` \u2192 the language (ops, frontmatter, composition, error-handling, connectors, lint-codes).\n- Draft \u2192 `lint_skill({source})` \u2192 `compile_skill({source})` \u2192 `skill_write({name, source})`.\n- **Robustness:** a failing fallible op aborts the target (in a fan-out, one throwing leg sinks the rest). Two shapes, two tools: a MISSING VALUE (dispatch error / empty) \u2192 `(fallback: \"\u2026\")`; a RAISED THROW (`$ json_parse` off-shape, `execute_skill` child-throw) \u2192 an `else:` handler or a structural guard \u2014 `(fallback:)` does NOT catch a throw. See `help({topic: \"error-handling\"})`.\n- It lands **Draft** \u2014 you can't self-approve; a human does. Treat anything you authored as not-yet-runnable until approved.";
|
|
11
11
|
export declare function helpResponse(topic: string | null, runtimeVersion: string, registry?: Registry): Record<string, unknown>;
|
|
12
12
|
//# sourceMappingURL=help-content.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"help-content.d.ts","sourceRoot":"","sources":["../src/help-content.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,
|
|
1
|
+
{"version":3,"file":"help-content.d.ts","sourceRoot":"","sources":["../src/help-content.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,ywDAakF,CAAC;AA48B9H,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,cAAc,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,QAAQ,GAClB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsBzB"}
|
package/dist/help-content.js
CHANGED
|
@@ -33,7 +33,7 @@ export const SKILLSCRIPT_USAGE_INSTRUCTIONS = `A Skillscript runtime is wired ov
|
|
|
33
33
|
**Repeating a routine? Capture it as a skill.** What you can script = the wired connectors, models, and allowed shell binaries from \`runtime_capabilities()\` — that list is your menu. When you catch yourself re-running work over any of them, author it. If something you'd need isn't wired yet, ask the operator to add it, then capture it.
|
|
34
34
|
- \`help({topic})\` → the language (ops, frontmatter, composition, error-handling, connectors, lint-codes).
|
|
35
35
|
- Draft → \`lint_skill({source})\` → \`compile_skill({source})\` → \`skill_write({name, source})\`.
|
|
36
|
-
- **Robustness:** a fallible op (
|
|
36
|
+
- **Robustness:** a failing fallible op aborts the target (in a fan-out, one throwing leg sinks the rest). Two shapes, two tools: a MISSING VALUE (dispatch error / empty) → \`(fallback: "…")\`; a RAISED THROW (\`$ json_parse\` off-shape, \`execute_skill\` child-throw) → an \`else:\` handler or a structural guard — \`(fallback:)\` does NOT catch a throw. See \`help({topic: "error-handling"})\`.
|
|
37
37
|
- It lands **Draft** — you can't self-approve; a human does. Treat anything you authored as not-yet-runnable until approved.`;
|
|
38
38
|
const QUICKSTART = `# Skillscript — quickstart
|
|
39
39
|
|
|
@@ -104,7 +104,7 @@ The legacy \`$(VAR)\` form still compiles with a tier-2 \`deprecated-substitutio
|
|
|
104
104
|
|
|
105
105
|
Most dispatch ops accept \`-> VAR\` to bind their output. Reference later via \`\${VAR}\`. Optional \`(fallback: "default")\` after \`-> VAR\` binds the fallback on dispatch error instead of propagating.
|
|
106
106
|
|
|
107
|
-
**A fallible op
|
|
107
|
+
**A fallible op that fails aborts the whole target** (and in a fan-out, takes the sibling legs down with it). Two failure shapes need two tools: a MISSING VALUE (dispatch error / empty result) is contained by \`(fallback: "…")\`; a RAISED THROW (\`$ json_parse\` off-shape, \`execute_skill\` child-throw) is NOT — it needs an \`else:\` handler or a structural guard (pre-bind defaults + a check before the risky op). See \`help({topic: "error-handling"})\`.
|
|
108
108
|
|
|
109
109
|
## 6. Branching
|
|
110
110
|
|
|
@@ -835,37 +835,49 @@ See \`help({topic: "examples"})\` example 4 for a worked orchestrator skill.
|
|
|
835
835
|
`;
|
|
836
836
|
const ERROR_HANDLING = `# Error handling & containment — keeping one failure from aborting the skill
|
|
837
837
|
|
|
838
|
-
**Skillscript has no try/catch — by design. Robustness is authored, not caught.** An unguarded
|
|
838
|
+
**Skillscript has no try/catch — by design. Robustness is authored, not caught.** An unguarded fallible op that FAILS aborts the whole target — and in a composition/fan-out, aborts every sibling op that hadn't run yet. Containing a failure means matching the tool to the failure SHAPE.
|
|
839
839
|
|
|
840
|
-
|
|
840
|
+
## Two failure shapes → two tools
|
|
841
841
|
|
|
842
|
-
|
|
842
|
+
- **MISSING VALUE** — the op dispatched but produced nothing usable: a \`$\`/\`shell\` dispatch error, a \`shell\` spawn-fail/timeout, empty (trimmed) output, or an unresolved/empty ref. Contain with a \`(fallback: "…")\` trailer on the op, or a \`fallback\` filter on the reference.
|
|
843
|
+
- **RAISED THROW** — the op dispatched OK but raised mid-execution: \`$ json_parse\` on off-shape input, or \`execute_skill\` whose child throws (e.g. the child's own output template references an unset var). A \`(fallback:)\` trailer does **NOT** catch this — the throw propagates past the trailer and aborts the target. Contain with an \`else:\` handler, or PREVENT it with a structural guard (pre-bind defaults + a shape/\`contains\` check before the risky op).
|
|
843
844
|
|
|
844
|
-
|
|
845
|
+
The single most common mistake: putting \`(fallback:)\` on an \`execute_skill\` leg and expecting it to survive a throwing child. It does not — verified end-to-end: \`execute_skill(child-that-throws) -> R (fallback:"…")\` still aborts the parent; an \`else:\` wrapper around it survives; a throw-proof child never fails.
|
|
846
|
+
|
|
847
|
+
## The containment tools
|
|
848
|
+
|
|
849
|
+
| Tool | Catches | Scope |
|
|
845
850
|
|---|---|---|
|
|
846
|
-
| \`(fallback: "…")\` op trailer |
|
|
847
|
-
|
|
|
848
|
-
| \`else:\` block |
|
|
849
|
-
|
|
|
851
|
+
| \`(fallback: "…")\` op trailer | a MISSING VALUE (dispatch error / spawn-fail / timeout / empty result) | the single op |
|
|
852
|
+
| \`fallback\` filter on a ref | a missing / unresolved / empty value at use-time | the single reference |
|
|
853
|
+
| \`else:\` block | a RAISED THROW anywhere in the target body — incl. an \`execute_skill\` child-throw and \`$ json_parse\` off-shape (both verified) | the whole target |
|
|
854
|
+
| structural guard (pre-bind + check) | PREVENTS the throw — most robust; a guarded op can't fail | the risky op |
|
|
850
855
|
|
|
851
|
-
|
|
856
|
+
(A \`# OnError: <skill>\` header is parsed but is NOT a reliable throw-container in the current runtime — prefer \`else:\`.)
|
|
852
857
|
|
|
853
858
|
## The discipline (5 rules)
|
|
854
859
|
|
|
855
|
-
**Rule 1 —
|
|
860
|
+
**Rule 1 — Guard each fallible op with the tool that matches its failure shape.** Produce-a-value ops (\`shell\`, \`$\` dispatch, \`file_read\`) that might return nothing → \`(fallback:)\`. Raise-capable ops (\`execute_skill\`, \`$ json_parse\`) → throw-proof the input or wrap the target in \`else:\`; a \`(fallback:)\` on them is a no-op against a throw.
|
|
856
861
|
|
|
857
|
-
**Rule 2 — In a fan-out,
|
|
862
|
+
**Rule 2 — In a fan-out, one throwing leg aborts every sibling.** A gather running N legs (weather + mailbox + calendar + …): a per-leg \`(fallback:)\` only covers a leg that returns EMPTY. A leg that THROWS — e.g. an \`execute_skill\` whose child raises — is NOT contained by that leg's \`(fallback:)\`; the throw propagates and the whole gather aborts, losing every later leg. Two patterns that work: **(a) preferred** — make each child throw-proof (pre-bind degraded defaults + guard the risky op) so a leg CANNOT throw and always returns a degraded value; **(b)** wrap the whole gather target in an \`else:\` handler that degrades and continues. (Observed 2026-07-05: one unguarded weather leg threw on a transient response and aborted a 7-leg morning brief — six healthy legs lost. The per-leg \`(fallback:)\` that "should" have caught it did not; the throw-proof-child rewrite is what held.)
|
|
863
|
+
|
|
864
|
+
Throw-proof child pattern (the verified fix):
|
|
858
865
|
\`\`\`
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
866
|
+
# Skill: get-weather
|
|
867
|
+
# Vars: RAW
|
|
868
|
+
Weather: \${AREA}
|
|
869
|
+
fetch:
|
|
870
|
+
$set AREA = "(weather unavailable)" # degraded default — always bound
|
|
871
|
+
if \${RAW|contains:"current_condition"}: # guard BEFORE the risky op
|
|
872
|
+
$ json_parse \${RAW} -> W
|
|
873
|
+
$set AREA = "\${W.nearest_area}"
|
|
874
|
+
default: fetch
|
|
863
875
|
\`\`\`
|
|
864
|
-
|
|
876
|
+
Bad input skips the \`if\`, \`AREA\` keeps its degraded default, the template renders, the child never throws — so a parent gather can't be sunk by it.
|
|
865
877
|
|
|
866
|
-
**Rule 3 — a
|
|
878
|
+
**Rule 3 — a \`fallback\` filter anywhere in a chain rescues an unresolved reference** (order-independent, v0.26.2+), and also rescues a missing dotted/numeric path on a present object: \`\${x|fallback:"d"}\`, \`\${x|trim|fallback:"d"}\`. A chain with no fallback throws on an unresolved ref — that's your signal to add one. It rescues only genuinely-unresolved refs; a present-but-empty value still flows through the other filters.
|
|
867
879
|
|
|
868
|
-
**Rule 4 — A body-text output template must not reference a var a fallible step might leave unset.** The template renders after the target runs;
|
|
880
|
+
**Rule 4 — A body-text output template must not reference a var a fallible step might leave unset.** The template renders after the target runs; an unset var hard-fails the render (\`Unresolved variable reference\`). This is also exactly how a child skill throws OUT to its \`execute_skill\` parent. Pre-bind every template var to a default before the fallible step (which doubles as the throw-prevention structure in Rule 2), or source each with a \`fallback\` filter.
|
|
869
881
|
|
|
870
882
|
**Rule 5 — Degrade LOUD, not silent.** A fallback value should be a visible marker ("unavailable", "—", "n/a") — never empty, never a plausible-but-wrong value. A degraded run must be diagnosable: surface that a leg degraded, don't silently ship a blank or a fake reading. Clean-throw-then-clean-degrade beats both a hard abort and a silent lie.
|
|
871
883
|
`;
|
package/dist/help-content.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"help-content.js","sourceRoot":"","sources":["../src/help-content.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,kEAAkE;AAClE,qEAAqE;AACrE,2BAA2B;AAC3B,EAAE;AACF,kBAAkB;AAClB,0EAA0E;AAC1E,+DAA+D;AAC/D,uCAAuC;AACvC,kFAAkF;AAClF,kFAAkF;AAClF,uDAAuD;AACvD,EAAE;AACF,uEAAuE;AACvE,yDAAyD;AAIzD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG;;;;;;;;;;;;;6HAa+E,CAAC;AAE9H,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmKlB,CAAC;AAEF,MAAM,GAAG,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0QX,CAAC;AAEF,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FnB,CAAC;AAEF,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuMhB,CAAC;AAEF,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EnB,CAAC;AAEF,MAAM,cAAc,GAAG
|
|
1
|
+
{"version":3,"file":"help-content.js","sourceRoot":"","sources":["../src/help-content.ts"],"names":[],"mappings":"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"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "skillscript-runtime",
|
|
3
|
-
"version": "0.26.
|
|
3
|
+
"version": "0.26.6",
|
|
4
4
|
"description": "Runtime, compiler, lint, CLI, and dashboard for Skillscript — a small declarative language for authoring agent workflows.",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"author": "Scott Shwarts <scotts@pobox.com>",
|