@neocompose/cli 0.4.1 → 0.5.1

package/README.md

@@ -1,15 +1,33 @@
-# `neo` — Neo Compose schema-as-code CLI
+# `neo` — Neo Compose project-source CLI
 
-`neo` keeps a Git-friendly C# working copy of a Neo Compose project schema,
-syncs it bidirectionally with Convex, and exposes NeoScript and content
-commands. Schema format v3 is compiler-backed: authored files are real C# 11,
-not a handwritten C# subset.
+`neo` synchronizes a Git-friendly Neo Compose project working copy with the
+web editor. Working-copy format 4 is Neo-native: `.neo` defines the project
+model and authored values, `.neoflow` defines dialogue flows, and managed image
+and audio files stay as ordinary binaries.
 
 The complete contract is in
-[`specs/schema-as-code-cli.md`](../specs/schema-as-code-cli.md). The concise
-agent workflow is in
+[`specs/neo-project-source-authoring.md`](../specs/neo-project-source-authoring.md).
+The concise agent workflow is in
 [`cli/skills/neocompose-cli/SKILL.md`](skills/neocompose-cli/SKILL.md).
 
+## Source architecture
+
+The CLI source separates authoring, document projection, and synchronization:
+
+```text
+project-source/   parse, lower, and emit .neo/.neoflow plus managed binaries
+project-manifest/ semantic bridge between authored source and project documents
+project-sync/     diff, merge, conflict, migration, and CAS state handling
+```
+
+The flow is `project source -> ProjectSchemaManifest -> project documents ->
+sync`. `ProjectSchemaManifest` carries an independently versioned serialized
+contract so source syntax and server documents can evolve without coupling
+their version numbers. The current workspace format is still format 4; the
+manifest's numeric contract version is not a second working-copy format.
+Dependencies point downward: `project-source` may use both lower layers, while
+`project-sync` never imports source-authoring or manifest code.
+
 ## Run
 
 ```sh
@@ -17,241 +35,361 @@ npm i -g @neocompose/cli       # published package; installs `neo` on PATH
 node cli/bin/neo.mjs <command> # repository development
 ```
 
-Neo does not install or download .NET. It first looks for a compatible Unity
-6000 runtime, then for a compatible system `dotnet`. Set `NEO_DOTNET_HOST` to
-an executable when discovery needs an explicit override. Run `neo doctor` to
-see the selected host, its compatibility result, the discovery cache, and the
-bundled schema-contract versions.
+Set up a working copy with explicit IDs in automation:
 
-## Format v3 working copy
+```sh
+neo login --profile editor
+neo init --project <id> --version <id> --dir neo
+```
+
+Interactive terminals may select the project, version, and directory. Neo
+does not install, discover, or require .NET. `neo doctor` validates the
+format-4 browser-safe compiler, VS Code analysis contract, tracked source, and
+managed-file capabilities.
+
+## Format-4 working copy
 
 ```text
 neo/
-  neo.json                         # includes formatVersion: 3
-  NeoCompose.Schema.csproj         # netstandard2.1, C# 11, IDE-only
-  Classes/                          # class declarations
-  Interfaces/                      # Neo interfaces
-  Enums/                           # Neo enums
-  Root.cs                          # [NeoRegistry] roots and loose members
-  Templates/                       # typed texture/audio settings
-  Localization.cs                 # typed localization settings
-  LocalizationStatuses/*.cs       # typed workflow-status settings
-  Scripts/<Class>/<Member>.neo     # tracked NeoScript sidecars
+  neo.json                         # formatVersion: 4
+  Project.neo                      # project defaults/settings
+  Root.neo                         # protected root shape; editable root values
+  Classes/
+  Interfaces/
+  Enums/
+  Relations.neo                    # generic project relations, when present
+  Templates/
+  Localization.neo
+  LocalizationStatuses/
+  Files/
+    Images.neo                     # ImageRegistry Images
+    AudioClips.neo                 # AudioClipRegistry AudioClips
+    Images/                        # tracked image bytes
+    AudioClips/                    # tracked audio bytes
+  DialogueGroups/
+  Dialogues/*.neoflow
   Migrations/*.neo
   .neo/
-    state.json                     # sync bases and CAS hashes
-    dotnet-host.json               # cached host discovery
-    tooling/                       # bundled SDK, analyzer, generator, compiler
+    state.json                     # private merge/CAS bases; never hand-edit
+    conflicts/
 ```
 
-`.neo/`, `bin/`, and `obj/` are gitignored. The C# project is an authoring
-project only; the game never references or ships it. The public
-`NeoCompose.Schema` SDK and analyzer are materialized from the npm package
-under `.neo/tooling`. There is no generated `Schema/NeoSchemaMembers.cs`.
+All non-hidden `.neo`, `.neoflow`, and supported managed binaries are tracked.
+`.neo/` is ignored private state. There is no schema `.csproj`, C# authoring
+tree, Roslyn compiler, generated authoring DLL, per-function sidecar tree, or
+checked-in dialogue JSON.
 
-Format v3 is a clean break and `neo.json` must contain `formatVersion: 3`.
-A workspace with a missing or different format version is unsupported. Preserve
-any source you need, then create a fresh v3 working copy with:
+Only `formatVersion: 4` is accepted. Format 4 is a clean break; it does not
+read or convert a format-3 C# checkout. Push intended changes with the older
+CLI first, preserve any local source you need, then reconstruct from the
+authoritative server:
 
 ```sh
-neo init --project <id> [--version <id>] [--dir neo]
+neo init --project <id> --version <id> --dir neo
 ```
 
-`neo pull --reset` remains available for an existing v3 workspace: it
-reconstructs its managed schema files from the server and refreshes tooling.
-
-## Real C# authoring
+For an existing format-4 workspace, `neo pull --reset` regenerates canonical
+source and managed binaries. Normal `neo pull` performs a stable-ID-aware
+three-way merge and preserves source placement when possible.
 
-Stable IDs remain visible so a Git rename stays a server rename. Everything
-C# already expresses is written as C#: modifiers, base classes, interfaces,
-generic parameters and constraints, nullability, defaults, declaration order,
-method arguments, return types, and deferred `Task` results.
+In Unity projects, `neo.json` may use `unityConfigPath` instead of storing
+`projectId` and `versionId`. The referenced `NeoComposeConfig.asset` then owns
+those IDs and receives branch/version switches.
 
-```csharp
-using System.Threading.Tasks;
-using NeoCompose.Schema;
+## Native Neo authoring
 
-[NeoSchemaClass("class-inventory-item")]
-public abstract partial class InventoryItem<
-    [NeoId("generic-stack-data")] TStackData>
-    where TStackData : InventoryStackData
-{
-    [NeoMember("member-name"), NeoText(SearchKey = true)]
-    public virtual string Name { get; init; } = "";
+Classes, interfaces, and enums are top-level declarations. Schema functions,
+getters, and setters live inline and compile as NeoScript; they do not have
+separate source files.
 
-    [NeoMember("member-type")]
-    public abstract ItemType Type { get; init; }
+```neo
+@id("enum-item-rarity-id")
+enum ItemRarity {
+  @id("rarity-common-id")
+  Common = "Common text",
+}
 
-    [NeoMember("member-description"), NeoComputed]
-    public virtual string Description { get; }
+@id("class-inventory-item-id")
+@storage(allowed: .Immutable)
+abstract class InventoryItem<
+  @id("inventory-context-generic-id")
+  TContext extends SomeClass
+> {
+  @id("item-name-id")
+  @settings(localizable: true, searchKey: true)
+  virtual string Name = "";
+
+  @id("item-rarity-id")
+  abstract ItemRarity Rarity;
+
+  @id("item-stack-size-id")
+  @settings(min: 1, max: 999)
+  int StackSize = 1;
+
+  @id("item-display-name-id")
+  string DisplayName {
+    get {
+      return $"{Name} ({Rarity})";
+    }
+  }
 
-    [NeoMember("function-use-primary"), NeoScript]
-    public virtual partial Task<bool> UsePrimary(InventoryItem<TStackData> target);
+  @id("item-use-id")
+  abstract void Use(TContext context);
 }
 ```
 
-- `virtual`, `abstract`, and `override` have their native meanings. An
-  override's base member ID is resolved from the Roslyn symbol graph.
-- Property type and nullability determine Neo kind and requiredness.
-- A property initializer is its default; declaration order is schema order.
-- A `static` property or method is class-owned. Stored static properties use a
-  replaceable binding and are not copied into instances; instance and static
-  receiver kinds cannot be changed in place.
-- Method signatures define function arguments and returns. `Task`/`Task<T>`
-  means deferred execution. The bundled source generator gives concrete
-  partial declarations inert compile-time implementations; authored schema
-  code is never executed.
-- `[NeoMember]` owns stable identity and common options. Narrow typed
-  attributes such as `[NeoText]`, `[NeoNumber]`, `[NeoList]`, `[NeoIndex]`,
-  `[NeoColumn]`, `[NeoLookup]`, `[NeoDialogue]`, and `[NeoFile]` express
-  Neo-specific behavior.
-- Nested entry graphs, texture/audio imports, localization, and uncommon
-  settings use strongly typed object initializers. Their complete option sets
-  participate in normal C# IntelliSense.
-
-For example, a concrete non-generic class can declare a class-owned stored
-member:
-
-```csharp
-[NeoSchemaClass("class-game-rules")]
-public partial class GameRules
-{
-    [NeoMember("member-encounter-count")]
-    public static int EncounterCount { get; set; }
-}
+The source identifier is the persisted name. `@settings` and `@storage` are
+typed by their declaration context; invalid fields and enum cases are
+diagnostics. Swift-like `.EnumCase` syntax works whenever the expected enum
+type is known. Focused annotations such as `@id`, `@locked`, `@system`, and
+`@relations` carry cross-cutting behavior.
+
+Stable IDs preserve identity across rename, reorder, and file moves. Omit an
+`@id` only to create something. A successful real push assigns the ID and
+rewrites source; dry-run, validation failure, upload failure, and CAS failure
+leave source byte-for-byte unchanged. Collection item identity uses the same
+native annotation:
+
+```neo
+Tags = [
+  @id("story-tag-item-id")
+  "story",
+];
 ```
 
-Only statically analyzable expressions are accepted: literals, enum values,
-`nameof`, `typeof`, arrays/collections, object initializers, and approved
-`Neo.*` reference constructors. The compiler never loads or executes the
-authored assembly. JSON carriers and identity escape hatches such as
-`ExtraJson`, `DefaultJson`, `RetJson`, `ArgsJson`, `EntryChainJson`,
-`SchemaKeyOrderJson`, `GenericParamIds`, `ChainJson`, `SignatureJson`,
-`ExtendsId`, `isVirtual`, and `isAbstract` do not exist in v3.
-
-Localization workflow statuses are ordinary stable records rather than IDs
-hidden in localization JSON:
-
-```csharp
-[NeoLocalizationStatus("localization-status-approved")]
-public sealed partial class Approved
-{
-    public static NeoLocalizationStatusSettings Settings { get; } = new()
-    {
-        Slug = "approved",
-        Name = "Approved",
-        Color = "#16a34a",
-        TransitionRules = new[] { "localization-status-needs-review" },
+## Root values and class-owned values
+
+`Root.neo` contains the compiler-owned `Root root = new() { ... }` envelope.
+Its member names, types, IDs, lock annotations, and storage settings are
+protected, while the `root.Assets`, `root.Save`, and `root.Session` value
+initializers are editable.
+
+Reusable values are stored static members on ordinary project classes. There
+is no `ValueRegistry` or generated `Values` namespace.
+
+```neo
+@id("assets-class-id")
+@storage(allowed: .Immutable)
+class Assets {
+  @id("capitol-member-id")
+  static Outpost Capitol =
+    @id("capitol-value-id")
+    new {
+      Name = "Capitol",
+      Image = Images.Capitol.Slice(0),
     };
+
+  @id("home-getter-id")
+  static Outpost Home {
+    get {
+      return Assets.Capitol;
+    }
+  }
 }
 ```
 
-## NeoScript sidecars
-
-NeoScript is tracked separately from C# metadata:
-
-- `Scripts/<DeclaringClass>/<Member>.neo` is the only canonical path.
-- Every file contains its complete contextual wrapper. The outer signature
-  mirrors the C# member and its NeoScript result type (`Task<T>` is represented
-  as `T`), then adds `<DeclaringClass> this, Root root`; this chrome is protected
-  in Monaco while the executable regions remain editable.
-- A computed property wrapper contains `get { ... }` and, when writable,
-  `set(<Type> value) { ... }` units.
-- A concrete `[NeoScript]` method wrapper contains a nested
-  `(<parameters>) { ... }` executable unit.
-- Abstract scripted members have no file.
-- Missing, duplicate, case-colliding, and orphaned sidecars are hard
-  diagnostics. Stable member IDs let canonical renames move sidecars safely.
-- Canonical C# includes a `// NeoScript: Scripts/...` link above each scripted
-  declaration. Definitions and navigation resolve in both directions between
-  that declaration and the sidecar wrapper.
-
-```neoscript
-string Description(InventoryItem this, Root root) {
-  get {
-    return $"{this.Name} ({this.Type})";
-  }
+Defaults materialize once when a value is created. Existing instances do not
+stay linked to later class-default changes. Logical lookup/dialogue references
+use the native typed intrinsic:
+
+```neo
+Reference(Assets.Capitol)
+Reference<Outpost>(id: "capitol-value-id")
+Reference<Dialogue>(id: "dialogue-id")
+```
+
+`Project.neo`, typed texture/audio templates, localization configuration and
+statuses, priority groups/options, dialogue groups, and direct relations use
+the same top-level typed declaration grammar. The compiler derives structural
+row identities, storage placement, generic stamps, localized-text links, and
+other persistence details that are not authorable source.
+
+## Files
+
+Images and audio are declared in typed registries and referenced directly:
+
+```neo
+ImageRegistry Images = new() {
+  @id("sword-image-file-id")
+  @settings(template: PixelArt)
+  NeoImage Sword = new("Files/Images/Sword.png");
 }
 
-bool UsePrimary(InventoryItem this, Root root) {
-  (InventoryItem target) {
-    return target.IsStackable;
+AudioClipRegistry AudioClips = new() {
+  @id("sword-hit-audio-file-id")
+  @settings(template: SoundEffect)
+  NeoAudioClip SwordHit = new("Files/AudioClips/SwordHit.wav");
+}
+```
+
+Use `Images.Sword.Slice(0)` for a sprite and `AudioClips.SwordHit` for an audio
+member. Dropping a supported binary into `Files/Images/` or
+`Files/AudioClips/` creates a provisional symbol; status/diff report it, and a
+successful push writes the explicit declaration and assigned ID. `neo files
+add` can create that pending declaration before push.
+
+Pull and push compare server-verified SHA-256 digests. Divergent local/remote
+bytes keep the local file and place the verified remote side under
+`.neo/conflicts/files/<file-id>/` until explicitly resolved.
+
+## NeoFlow dialogue authoring
+
+Each `.neoflow` file contains exactly one sealed, non-generic class directly
+derived from the system `Dialogue` type and exactly one required trigger
+override. Dialogue functions and lexical value bindings are ordinary typed
+Neo code. Main-locale prose is inline; other locales and workflow metadata
+remain in localized-text records.
+
+Graph constructors use NeoFlow-only trailing bodies. `=> Node` and a final
+`return Node;` are equivalent destinations; there is no authorable `to:`
+argument. Terminal text/actions nodes may omit a destination, while triggers,
+options, and outcomes require one.
+
+```neoflow
+@id("capitol-dialogue-id")
+@settings(name: "Capitol: cold boot", saveOptionChoices: true)
+sealed class CapitolColdBoot : Dialogue {
+  @primary Outpost capitol = Assets.Capitol;
+
+  @id("can-start-function-id")
+  bool CanStart() {
+    return capitol.Name == "Capitol";
+  }
+
+  @id("capitol-trigger-id")
+  override Trigger Trigger = new(
+    group: CapitolDialogues.High,
+    when: [
+      @id("can-start-condition-use-id")
+      CanStart,
+    ]
+  ) => Welcome;
+
+  @id("welcome-node-id")
+  Text Welcome = new(name: "Welcome!") {
+    """
+    Welcome to {capitol.Name}.
+    """
+
+    @id("continue-option-id")
+    Option Continue = new() {
+      """
+      Tell me more.
+      """
+      return Finish;
+    }
+  }
+
+  @id("finish-node-id")
+  Text Finish = new() {
+    """
+    Until next time.
+    """
   }
 }
 ```
 
-All executable body kinds use the same mutation-capable resolver and executor.
-Getters and code-authored conditions may write to Save, Session, runtime, or
-setter-backed targets; Immutable targets remain read-only. Body kind still
-controls return/deferred-call rules, not storage writability.
-
-Locals may use either an explicit type or `var`; inferred locals retain the
-same exact type and language features. Concrete, closed, writable Classes
-support `new ClassName(...)` in the same required-then-optional parameter order as
-generated C#. Optional parameters have inferred `null` defaults and are
-positional, so pass `null` to skip an earlier optional slot. Constructor-call
-signature help and parameter-name inlay hints come from that shared signature;
-the names are previews, not authored named-argument syntax.
-Fresh constructor graphs use Session ownership and are reclaimed at invocation
-completion unless attached, returned, passed onward, or otherwise escaped.
-
-Static access uses the declaring Class (`GameRules.EncounterCount`); stored
-static members resolve through their authored, Save, or Session binding layer.
-
-The browser-safe `neoscript-language` package is authoritative for the CLI,
-server compiler, web Monaco editor, and VS Code LSP. Monaco's existing syntax
-highlighting, comments/interpolation, scaffolds and protected regions,
-project-aware completion, hover, and accurate diagnostics are a
-release-blocking compatibility floor. The shared service also adds
-parser-recovery completion, signature help, definitions into C#, references,
-rename, symbols, semantic tokens, quick fixes, formatting, richer related
-diagnostics, contextual ranking, and incremental analysis. The in-repo VSIX
-uses the same results; marketplace publication is a separate release step.
+Persisted condition uses, action invocations, mutations, pauses, options, and
+outcomes each have their own stable `@id`. References made through lexical
+bindings and transitive function calls derive the same linked values as the
+web editor. Run `neo dialogue dryrun <ref>` after dialogue edits to traverse
+option paths against a fresh save and catch runtime storage-ownership errors.
+
+## Synchronization workflow
+
+```sh
+neo pull
+# edit .neo, .neoflow, and managed binaries
+neo status
+neo diff
+neo dialogue dryrun <ref>
+neo push --dry-run
+neo push
+```
+
+A pull followed immediately by status or push dry-run must be a semantic
+no-op. If it reports authoring changes, stop and report a round-trip bug rather
+than pushing.
+
+Pull merges source concepts and collections by stable identity, never by
+index. Conflicts are explicit and block compilation. Edit source to the
+desired result, or use `neo resolve --mine|--theirs` as a whole-side
+convenience. There is no force-CAS bypass. Accept a required compatibility
+bump only after reviewing it with `neo push --accept-bump`.
+
+One push recompiles the complete source bundle at the trusted server boundary
+and atomically commits semantic record changes, localized main-locale edits,
+and staged files under CAS. Client AST, compiled IR, placement stamps, and
+derived links are not trusted.
+
+Optional scaffolds edit pending local source and never push:
+
+```sh
+neo class new InventoryItem --abstract
+neo value new Outpost --member Assets.Capitol --into root.Assets.Outposts
+neo files add Files/Images/Sword.png --template PixelArt
+neo dialogue new CapitolColdBoot --primary Outpost=Assets.Capitol --group CapitolDialogues
+```
 
 ## Commands
 
-| Command                                   | Purpose                                                                                            |
-| ----------------------------------------- | -------------------------------------------------------------------------------------------------- |
-| `login`                                   | Device-code OAuth; use `--profile release`, `--token-stdin`, or `NEO_COMPOSE_TOKEN` as appropriate |
-| `init --project <id> [--version <id>]`    | Scaffold a format-v3 working copy and perform the first pull                                       |
-| `doctor`                                  | Report runtime discovery, compatibility, cache, tooling, and contract versions                     |
-| `pull [--reset]`                          | Sync or reconstruct; normal pulls use record-level three-way merge                                 |
-| `status` / `diff`                         | Compile the working copy and compare its manifest with the base                                    |
-| `push [--dry-run] [--accept-bump]`        | Preview or commit one atomic compare-and-swap transaction                                          |
-| `dev [--push]`                            | Watch the Convex sync signal and local files; pushing remains opt-in                               |
-| `resolve --mine\|--theirs`                | Conflict-marker convenience; editing the final source is authoritative                             |
-| `script check\|compile\|eval\|apply`      | Use the shared NeoScript compiler/evaluator and report values, writes, and surviving Session rows  |
-| `records` / `values` / `loc` / `dialogue` | Read and batch-edit content, including stored static bindings, without schema-source value files   |
-
-`neo script eval --json` reports `value`, ordered `writes`, and
-`createdSessionValues`. The last field contains only constructor rows that
-escaped invocation cleanup. Use `neo values bind`, `neo values unbind`, or an
-atomic `neo values create ... --bind <staticMemberId>` operation to manage
-an authored stored-static binding.
-
-The central invariant is unchanged: a pull followed immediately by status or
-push must produce no changes. The manifest contract classifies every field as
-authored, derived, or volatile and preserves derived server data from the base
-record. A newly introduced authored server field fails with “CLI contract
-upgrade required” instead of being hidden in opaque JSON.
+| Command                                                  | Purpose                                                                      |
+| -------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| `login` / `whoami`                                       | Authenticate and inspect the selected profile.                               |
+| `init --project <id> [--version <id>]`                   | Create a format-4 working copy and perform its first reset pull.             |
+| `doctor`                                                 | Validate format/compiler/editor/source/file contracts; no .NET discovery.    |
+| `pull [--force\|--reset]`                                | Merge remote changes or regenerate canonical source and binaries.            |
+| `status [--json]` / `diff [--json]`                      | Compile source and show semantic records, spans, digests, and upload intent. |
+| `push [--dry-run] [--accept-bump]`                       | Validate or commit one atomic compare-and-swap transaction.                  |
+| `dev [--push]`                                           | Watch remote/local changes; pushing remains opt-in.                          |
+| `resolve --mine\|--theirs`                               | Resolve all current source/binary conflicts with one side.                   |
+| `class new` / `value new` / `files add` / `dialogue new` | Create pending native source scaffolds.                                      |
+| `script check\|compile\|eval\|apply`                     | Compile or preview NeoScript with project context.                           |
+| `migrate new\|list\|check\|run\|prune`                   | Author and manage tracked NeoScript migrations.                              |
+| `branch` / `merge` / `release` / `channel` / `history`   | Manage branches, releases, channels, and retained history.                   |
+| `records` / `values` / `loc` / `dialogue` / `files`      | Low-level content and repair operations.                                     |
+| `export unity`                                           | Export the runtime Unity projection.                                         |
+
+Low-level write commands mutate the same authoritative records as the web
+editor. They are useful for repair and automation, but do not edit checked-in
+source; run `neo pull` immediately afterward. Whole-dialogue JSON
+export/apply is not a source format and is not available.
+
+Tokens use the OS credential store when available and a protected local file
+only as fallback. CI can use `NEO_COMPOSE_TOKEN` or `--token-stdin`. The
+editor profile cannot publish releases; server authorization remains the
+security boundary.
+
+## Regenerating dialogue source names
+
+Normal pull preserves source filenames and symbols by stable record ID. To
+deliberately replace older machine-generated dialogue names with readable
+names derived from the editor, run:
+
+```sh
+neo pull --reset --regenerate-source-names
+neo status
+neo push --dry-run
+```
+
+The reset leaves the regenerated names as local changes. IDs are unchanged,
+and nothing is written to the server until `neo push` succeeds.
 
 ## Packaging
 
-`node cli/build.mjs` bundles the Node orchestrator and shared TypeScript code,
-builds the Roslyn sidecar, and places the prebuilt compiler, dependencies,
-runtime metadata, C# SDK, analyzer, and source generator in `dist/tooling`.
-The npm package contains the entire toolchain except a .NET host. Published
-contents and CLI/SDK/manifest contract versions are release-tested.
+`node cli/build.mjs` bundles the Node orchestrator and browser-safe Neo
+language/compiler/editor assets. The npm package contains no C# SDK, Roslyn
+application, DLL, or .NET runtime metadata. Package checks reject those
+artifacts and verify that the shared compiler assets and skill are present.
 
 Useful checks while developing:
 
 ```sh
 npm run typecheck
 npx vitest run cli
-npm run build
+npm --prefix cli run test:package
 ```
 
-Run the repository's full verification suite before release, package the
-VSIX, exercise the Unity and Hello World samples through their documented
-Unity workflow, verify a live `neowyn` pull/status/push dry run, and run
-`npm run doctor` last.
+Run the repository's full verification suite before release, package and
+exercise the VS Code extension, verify the Hello World and live `neowyn`
+format-4 no-op workflows, and run `npm run doctor` last.