@aryacode/dsh-engineering 0.4.20 → 0.4.21

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.4.21] - 2026-10-27
+
+### Changed
+
+- **One backup tree for every engineering product.** Backups land in
+  `<workspace>/backups/<product>/<subject>/<UTC stamp>/` with a `backup-manifest.json` naming every
+  copied file and its SHA-256: `motionworks` for the `.mwt` and its expanded folder, `l5x` for the ACD
+  or L5X, `ftview` for an export folder, `optix` for a Studio project export. Studio 5000 and
+  FactoryTalk View take one on request (their writes already produce a new file or folder); Optix has
+  the location but no automated action here, because its tree is the prebuilt component. Every skill
+  states the same tree and a test fails when one drifts. `<workspace>/_backups` and the pre-0.4.21
+  `<workspace>/backups/<project>/<stamp>/` layout are read-only history and are never written.
+- **MotionWorks moves its copies into that tree.** `mw_project_open` writes
+  `backups/motionworks/<project>/<stamp>/`, and both the bridge (`Get-DirectIdentity`) and the engine
+  (`assert_direct_attached`) accept a record that points at the old `.motionworks/attached/backups`
+  root, so an existing workspace keeps its verified backup with no migration and no second copy.
+
+### Fixed
+
+- **`pnpm pack` can no longer ship a stale component.** `scripts/assemble.mjs` refuses a component
+  whose `lib/` is older than its `src/`, and the release procedure builds the components before
+  packing. That is how the 0.4.20 market tarball came to carry the 0.4.16 MotionWorks build under a
+  0.4.20 version.
+
 ## [0.4.20] - 2026-10-27
 
 ### Fixed

package/README.md

@@ -180,7 +180,13 @@ even when the implementation behind a row is replaced.
 - **Edits write new files.** `draft_apply` writes one new L5X beside the source and refuses to
   overwrite; `ftview_apply` writes a new export folder and leaves the source untouched. MotionWorks
   edits write the real workspace project, after one complete backup under
-  `<workspace>/.motionworks/attached/`, and verify unrelated saved and native state.
+  `<workspace>/backups/motionworks/`, and verify unrelated saved and native state.
+- **One backup tree.** Every product backs up into
+  `<workspace>/backups/<product>/<subject>/<UTC stamp>/` with a `backup-manifest.json` naming each
+  copied file and its SHA-256, so "back up this project" means the same place in every skill.
+  MotionWorks takes its backup on open; L5X, FactoryTalk View and Optix take one on request and before
+  an in-place change. `<workspace>/_backups` and `<workspace>/backups/<project>/…` are older layouts
+  and are never written.
 - **Controller changes need a human.** Upload, mode change and download require per-call approval and
   a session policy that permits asking. The tools refuse before contacting a controller when approval
   is unavailable, and a download accepts only a verification id produced by a passed build.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aryacode/dsh-engineering",
-  "version": "0.4.20",
+  "version": "0.4.21",
   "description": "AryaCode engineering bundle: one install surface for the Studio 5000 L5X, FactoryTalk View ME, MotionWorks IEC and FactoryTalk Optix surfaces, one row per product, with the ladder and display previews.",
   "keywords": [
     "dsh",

package/vendor/ftview/SKILL.md

@@ -13,6 +13,23 @@ A staged edit is written to a NEW export folder; the source is never modified. T
 a manual import for a human; it does not drive Studio, contact a terminal, or decode MER or MED
 databases.
 
+## Backups
+
+Every engineering product backs up into the same tree, so a backup means one place whichever surface
+you are in:
+
+```
+<workspace>/backups/<product>/<subject>/<UTC stamp>/
+    backup-manifest.json      every copied file: relative path + SHA-256
+    <the copy>
+```
+
+FactoryTalk View is the `ftview` product: the copy is the whole export folder (display XML plus the tag
+CSV), one stamp per backup. `ftview_apply` already writes a new folder, so this is a backup on request
+("back up this export"). Build it as a copy plus `backup-manifest.json` listing every file's relative
+path and SHA-256. `<workspace>/_backups` and `<workspace>/backups/<project>/…` are older layouts: never
+write there, and leave what is there alone.
+
 ## Start
 
 1. Call `ftview_open` with the export folder. Keep the returned `view_id`.

package/vendor/l5x/SKILL.md

@@ -10,6 +10,23 @@ whenToUse: Use when the user asks about a Studio 5000 L5X export, Logix tags, ro
 
 This surface reads and drafts. A draft writes only a new L5X file: it never overwrites the source, imports into Studio, connects to a controller, changes mode, or writes runtime data.
 
+## Backups
+
+Every engineering product backs up into the same tree, so a backup means one place whichever surface
+you are in:
+
+```
+<workspace>/backups/<product>/<subject>/<UTC stamp>/
+    backup-manifest.json      every copied file: relative path + SHA-256
+    <the copy>
+```
+
+Studio 5000 is the `l5x` product: the copy holds the `.ACD` being worked on, or the `.L5X` export when
+that is the source of truth, one stamp per backup. Drafts and SDK builds already write new files, so
+this is a backup on request ("back up this project"). Build it as a copy plus
+`backup-manifest.json` listing every file's relative path and SHA-256. `<workspace>/_backups` and
+`<workspace>/backups/<project>/…` are older layouts: never write there, and leave what is there alone.
+
 ## Start
 
 1. Call `open_project` with the export path. Keep the returned `project_id`.

package/vendor/mwi/README.md

@@ -2,14 +2,16 @@
 
 MotionWorks IEC 3 Pro tools, redesigned for the `dsh-engineering` bundle. The product edits the
 **real workspace project**: `mw_project_open` writes one complete hash-verified backup under
-`<workspace>/.motionworks/attached/` first, then drives the running IDE through the existing 32-bit
-COM bridge. A project the IDE already has open is attached (backup recorded) instead of reloaded, so
-unsaved editor changes survive. `mw_project_stage` remains as an optional sandbox.
+`<workspace>/backups/motionworks/<project>/<stamp>/` first, then drives the running IDE through the
+existing 32-bit COM bridge. A project the IDE already has open is attached (backup recorded) instead of
+reloaded, so unsaved editor changes survive. `mw_project_stage` remains as an optional sandbox.
 
-The backup layout is a contract, not a convention: the shipped bridge (`Get-DirectIdentity`) and the
-read-only engine (`assert_direct_attached`) refuse a real project unless an identity record names a
-backup under `.motionworks/attached/backups` with a manifest whose SHA-256 matches. Writing the copy
-anywhere else is what made every direct open fail.
+`<workspace>/backups/<product>/<subject>/<stamp>/` is the one tree every engineering product writes
+under, so a backup is one place whichever surface the user is in. MotionWorks is the product whose
+backup is also a contract: the shipped bridge (`Get-DirectIdentity`) and the read-only engine
+(`assert_direct_attached`) refuse a real project unless an identity record names a copy in that tree,
+with a manifest whose SHA-256 matches. Records written before 0.4.21 that point at
+`.motionworks/attached/backups` stay valid.
 
 ## Rows
 
@@ -33,7 +35,7 @@ Edit tools: `mw_edit_code`, `mw_edit_variables`, `mw_edit_structure`, `mw_insert
 
 Verified against MotionWorks IEC 3 Pro 1.19 with a copy of a real project in a temporary workspace:
 
-1. `open` writes `.motionworks/attached/backups/<id>/` with `backup-manifest.json` and
+1. `open` writes `backups/motionworks/<project>/<stamp>/` with `backup-manifest.json` and
    `.motionworks/attached/records/<id>.json`, verified before the IDE is asked to open anything, and
    reuses that backup on later attaches.
 2. A project already open in the IDE is attached without an `OpenProject` call: `mw_project_open`

package/vendor/mwi/SKILL.md

@@ -9,12 +9,25 @@ whenToUse: The user has MotionWorks IEC 3 Pro open or asks for work in it — a
 ## Boundary
 
 This surface edits the **real workspace project**. `mw_project_open` takes one complete, hash-verified
-backup under `<workspace>/.motionworks/attached/` before the IDE opens the project, and reuses that
+backup under `<workspace>/backups/motionworks/` before the IDE opens the project, and reuses that
 backup for later attaches. A project the IDE already has open is attached — the backup is written and
 the project is **not** reloaded, so unsaved editor changes survive. `mw_project_stage` remains
 available as an optional sandbox when you want the IDE to open a copy instead. Nothing here downloads
 to a controller or commands motion.
 
+Every engineering product backs up into the same tree, so a backup means one place whichever surface
+you are in:
+
+```
+<workspace>/backups/<product>/<subject>/<UTC stamp>/
+    backup-manifest.json      every copied file: relative path + SHA-256
+    <the copy>
+```
+
+MotionWorks is the `motionworks` product and the copy holds the project's `.mwt` beside its expanded
+folder. The open already takes it; do not take a second one. `<workspace>/_backups` and
+`<workspace>/backups/<project>/…` are older layouts: never write there, and leave what is there alone.
+
 The native IDE API is the editing path. Desktop input belongs to the computer-use companion and is a
 fallback for operations without a native call, never a substitute for a refused native one.
 

package/vendor/mwi/bridge/mw_bridge.ps1

@@ -1019,7 +1019,11 @@ function Get-DirectIdentity([string]$path) {
         try { $raw = Get-Content -LiteralPath $file.FullName -Raw -Encoding UTF8 | ConvertFrom-Json }
         catch { continue }
         if ([string]$raw.mode -cne 'direct' -or -not (Test-SameProject ([string]$raw.mwt) $path)) { continue }
-        $backupRoot = Normalize-MwPath (Join-Path $script:WorkspaceRoot '.motionworks\attached\backups')
+        # One workspace backup tree for every engineering product:
+        # <workspace>\backups\<product>\<subject>\<stamp>. Records written before
+        # 0.4.21 point at .motionworks\attached\backups and stay valid.
+        $backupRoot = Normalize-MwPath (Join-Path $script:WorkspaceRoot 'backups\motionworks')
+        $legacyRoot = Normalize-MwPath (Join-Path $script:WorkspaceRoot '.motionworks\attached\backups')
         $backup = Normalize-MwPath ([string]$raw.backup)
         $manifestPath = Normalize-MwPath ([string]$raw.backup_manifest)
         if (-not (Test-InsideWorkspace $backup) -or -not (Test-InsideWorkspace $manifestPath)) { return $null }
@@ -1029,7 +1033,8 @@ function Get-DirectIdentity([string]$path) {
             -not (Test-SameProject ([string]$raw.directory) $path) -or
             -not (Test-Path -LiteralPath ([string]$raw.mwt)) -or
             -not (Test-Path -LiteralPath ([string]$raw.directory)) -or
-            -not $backup.StartsWith($backupRoot + '\', [StringComparison]::OrdinalIgnoreCase) -or
+            -not ($backup.StartsWith($backupRoot + '\', [StringComparison]::OrdinalIgnoreCase) -or
+                $backup.StartsWith($legacyRoot + '\', [StringComparison]::OrdinalIgnoreCase)) -or
             -not $manifestPath.StartsWith($backup + '\', [StringComparison]::OrdinalIgnoreCase) -or
             -not (Test-Path -LiteralPath ([string]$raw.backup_manifest))) { return $null }
         if ((Get-MwSha256 ([string]$raw.backup_manifest)) -ine [string]$raw.backup_manifest_sha256) { return $null }

package/vendor/mwi/code/engine/motionworks_iec_mcp/staging.py

@@ -149,9 +149,13 @@ def assert_direct_attached(project_root: Path | str) -> Path:
                 continue
             backup = Path(record["backup"]).resolve()
             manifest = Path(record["backup_manifest"]).resolve()
-            backup_root = workspace / ".motionworks" / "attached" / "backups"
+            # One workspace backup tree for every engineering product:
+            # <workspace>/backups/<product>/<subject>/<stamp>. Records written
+            # before 0.4.21 point at .motionworks/attached/backups and stay valid.
+            backup_root = workspace / "backups" / "motionworks"
+            legacy_root = workspace / ".motionworks" / "attached" / "backups"
             if (Path(record["workspace"]).resolve() != workspace
-                    or not _inside(backup, backup_root)
+                    or not (_inside(backup, backup_root) or _inside(backup, legacy_root))
                     or not _inside(manifest, backup)
                     or not manifest.is_file()
                     or hashlib.sha256(manifest.read_bytes()).hexdigest() != record["backup_manifest_sha256"]

package/vendor/mwi/lib/session/backup.d.ts

@@ -3,13 +3,18 @@
  *
  * Editing happens on the real workspace project. The first write takes one
  * complete, hash-verified copy under
- * `<workspace>/.motionworks/attached/backups/<id>`, writes a manifest beside it
- * and records the project identity in `<workspace>/.motionworks/attached/records`.
+ * `<workspace>/backups/motionworks/<project>/<UTC stamp>`, writes a manifest
+ * beside it and records the project identity in
+ * `<workspace>/.motionworks/attached/records`.
  *
- * That layout is the contract the shipped bridge (`Get-DirectIdentity`) and the
- * read-only engine (`assert_direct_attached`) already verify before they open,
- * read or write a real project. A copy anywhere else is not evidence: those
- * guards refuse the open, so the tools must write exactly this shape.
+ * `<workspace>/backups/<product>/…` is the one backup tree every engineering
+ * product writes under, so "back up this project" means the same place whichever
+ * product is in front of you. MotionWorks keeps its identity records private
+ * under `.motionworks`, and both the shipped bridge (`Get-DirectIdentity`) and
+ * the read-only engine (`assert_direct_attached`) verify a record before they
+ * open, read or write a real project. A copy outside that tree is not evidence:
+ * those guards refuse it, so the tools must write exactly this shape. Records
+ * written before 0.4.21 that point at `.motionworks/attached/backups` stay valid.
  *
  * @module dsh-engineering-mwi/session/backup
  */
@@ -37,8 +42,20 @@ export interface BackupRecord {
     /** When the copy was written. */
     readonly created_at: string;
 }
-/** The shared backup root of one workspace. */
+/**
+ * The workspace backup root every engineering product writes under:
+ * `<workspace>/backups/<product>/<subject>/<UTC stamp>/`.
+ *
+ * MotionWorks is the `motionworks` product. Keeping the copies in one visible
+ * tree is what makes "back up this project" mean the same place for every
+ * product; the identity records stay product-private under `.motionworks`.
+ */
 export declare function backupRootOf(workspace: string): string;
+/**
+ * The pre-0.4.21 backup root. Records written by earlier builds point here and
+ * stay valid: a shipped record is evidence, so it is accepted, never rewritten.
+ */
+export declare function legacyBackupRootOf(workspace: string): string;
 /** The identity record directory of one workspace. */
 export declare function recordRootOf(workspace: string): string;
 /** Read the record for a project, when a valid backup exists. */

package/vendor/mwi/lib/session/backup.js

@@ -3,13 +3,18 @@
  *
  * Editing happens on the real workspace project. The first write takes one
  * complete, hash-verified copy under
- * `<workspace>/.motionworks/attached/backups/<id>`, writes a manifest beside it
- * and records the project identity in `<workspace>/.motionworks/attached/records`.
+ * `<workspace>/backups/motionworks/<project>/<UTC stamp>`, writes a manifest
+ * beside it and records the project identity in
+ * `<workspace>/.motionworks/attached/records`.
  *
- * That layout is the contract the shipped bridge (`Get-DirectIdentity`) and the
- * read-only engine (`assert_direct_attached`) already verify before they open,
- * read or write a real project. A copy anywhere else is not evidence: those
- * guards refuse the open, so the tools must write exactly this shape.
+ * `<workspace>/backups/<product>/…` is the one backup tree every engineering
+ * product writes under, so "back up this project" means the same place whichever
+ * product is in front of you. MotionWorks keeps its identity records private
+ * under `.motionworks`, and both the shipped bridge (`Get-DirectIdentity`) and
+ * the read-only engine (`assert_direct_attached`) verify a record before they
+ * open, read or write a real project. A copy outside that tree is not evidence:
+ * those guards refuse it, so the tools must write exactly this shape. Records
+ * written before 0.4.21 that point at `.motionworks/attached/backups` stay valid.
  *
  * @module dsh-engineering-mwi/session/backup
  */
@@ -18,8 +23,22 @@ import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSy
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { MwiError } from "../core/errors.js";
 import { isInside } from "./workspace.js";
-/** The shared backup root of one workspace. */
+/**
+ * The workspace backup root every engineering product writes under:
+ * `<workspace>/backups/<product>/<subject>/<UTC stamp>/`.
+ *
+ * MotionWorks is the `motionworks` product. Keeping the copies in one visible
+ * tree is what makes "back up this project" mean the same place for every
+ * product; the identity records stay product-private under `.motionworks`.
+ */
 export function backupRootOf(workspace) {
+    return join(workspace, 'backups', 'motionworks');
+}
+/**
+ * The pre-0.4.21 backup root. Records written by earlier builds point here and
+ * stay valid: a shipped record is evidence, so it is accepted, never rewritten.
+ */
+export function legacyBackupRootOf(workspace) {
     return join(workspace, '.motionworks', 'attached', 'backups');
 }
 /** The identity record directory of one workspace. */
@@ -66,7 +85,11 @@ function valid(workspace, record) {
             return false;
         if (!same(record.directory, record.mwt.slice(0, -4)))
             return false;
-        if (!isInside(backupRootOf(workspace), record.backup) || !isInside(record.backup, record.backup_manifest))
+        const root = backupRootOf(workspace);
+        const legacy = legacyBackupRootOf(workspace);
+        if (!isInside(root, record.backup) && !isInside(legacy, record.backup))
+            return false;
+        if (!isInside(record.backup, record.backup_manifest))
             return false;
         if (!existsSync(record.mwt) || !existsSync(record.directory) || !existsSync(record.backup_manifest))
             return false;
@@ -179,7 +202,9 @@ export function ensureBackup(workspace, path) {
         }
     }
     const id = randomUUID();
-    const target = join(backupRootOf(workspace), id);
+    const name = basename(mwt, '.mwt');
+    const stamp = new Date().toISOString().replace(/[:.]/gu, '-');
+    const target = join(backupRootOf(workspace), name, stamp);
     const files = [];
     const sources = [mwt];
     tree(directory, sources);