Pass shared workspace palette to child tool launches - PR 11.28

Author: DavidQ

docs/dev/codex_commands.md

@@ -2,32 +2,33 @@ MODEL: GPT-5.3-codex
 REASONING: high
 
 TASK:
-Apply PR 11.27.
-
-Reset the working recovery baseline to:
-
-4dc2b0f: Show Workspace Manager asset status from embedded tool payloads - PR 11.22
-
-Use that as the source of truth because it loaded the JSON and displayed the correct full Workspace Manager workspace.
-
-Then fix ONLY the remaining issue:
-- many Workspace Manager tool buttons are grayed out/disabled even though embedded payload data exists.
-
-Do NOT carry forward today's failed changes unless independently required and verified:
-- do not reapply PR 11.23 binding/cache behavior that caused palette-only
-- do not reapply PR 11.25 forward-fix behavior that still failed
-- do not remove payload fan-out
-- do not collapse visible tools to palette-only
-
-Do NOT restore or change PR 11.24 page cleanup unless it already exists after resetting. The priority is Workspace Manager correctness from 4dc2b0f.
+Apply PR 11.28.
+
+Starting from the current `4dc2b0f`-based recovery state, fix the remaining launch dependency issue:
+- Workspace Manager shows full sample 1902 workspace.
+- Vector Map can be clicked.
+- Vector Map opens but says palette is missing.
+- Most other palette-dependent tools are still grayed out.
+
+Do NOT restart the failed PR 11.23/11.25 approach.
+Do NOT collapse the workspace to palette-only.
+Do NOT add hardcoded or hidden fallback data.
+Do NOT require selectedAssetId, assetRegistry, or external file references when embedded payload exists.
+
+Required behavior:
+- Workspace Manager child launches must include or resolve shared workspace palette payload from the same sample-owned JSON already loaded for sample 1902.
+- `manifest.tools.palette` should satisfy the shared palette dependency for child tools.
+- `manifest.tools[toolId]` should satisfy the tool's own embedded payload dependency.
+- Palette-dependent tools should be enabled when both their own payload and the shared palette payload exist.
+- True utilities can remain N/A or disabled only with documented reason.
 
 Implementation guidance:
-1. Inspect Workspace Manager/tool launch button disabled logic.
-2. Compare status-display rules from 4dc2b0f with button-enable rules.
-3. Make enablement consider embedded payload presence as valid launch data.
-4. Keep utility tools handled separately as N/A where appropriate.
-5. Avoid selectedAssetId/assetRegistry/external-file requirements for embedded-payload tools.
-6. Keep the fix surgical and localized.
+1. Find the child tool launch/context handoff code in tools/shared/platformShell.js or directly related Workspace Manager code.
+2. Find where Vector Map reports palette missing.
+3. Connect that missing dependency to the workspace manifest palette payload, not to a default or external asset.
+4. Adjust disabled-state logic so palette-dependent payload tools are not blocked when `manifest.tools.palette` exists.
+5. Keep palette fallback local to dependency satisfaction, not workspace tool-list selection.
+6. Add no broad refactor.
 
 Validation:
 node --check tools/shared/platformShell.js
@@ -36,17 +37,17 @@ node ./tests/runtime/LaunchSmokeAllEntries.test.mjs --samples --sample-range=190
 Manual validation:
 Open sample 1902.
 Open Workspace Manager.
+Click Vector Map Editor.
 Confirm:
-- full workspace is visible
-- not palette-only
-- payload-backed editor buttons are enabled/openable
-- asset/status labels are still visible
+- no missing palette message
+- vector map opens with palette context
+Return to Workspace Manager.
+Confirm palette-dependent tools with embedded payload are enabled/openable.
 
 REPORT:
-Write docs/dev/reports/PR_11_27_validation.txt with:
-- baseline commit used
-- files changed
-- root cause of grayed-out buttons
-- why payload presence now enables launch
-- validation commands/results
-- manual validation notes
+Write docs/dev/reports/PR_11_28_validation.txt with:
+- changed files
+- root cause of missing palette message
+- how shared palette handoff now works
+- which buttons remain disabled and why, if any
+- validation command results

docs/dev/commit_comment.txt

@@ -1 +1 @@
-Enable Workspace Manager tool buttons from embedded payload baseline - PR 11.27
+Pass shared workspace palette to child tool launches - PR 11.28

docs/dev/reports/PR_11_28_validation.txt

@@ -0,0 +1,33 @@
+PR 11.28 Validation Report
+
+Changed files:
+- tools/shared/platformShell.js
+- docs/dev/reports/PR_11_28_validation.txt
+
+Root cause of missing palette message:
+- Shared palette dependency was not being resolved from the workspace sample manifest tool payload contract.
+- `readPaletteFromManifestPayload(...)` did not accept strict workspace tool payload shapes (`tools.palette.payload` and `tools["palette-browser"].payload`).
+- As a result, shared palette handoff stayed empty for child launches even when sample 1902 contained explicit palette payload data.
+
+How shared palette handoff now works:
+- Added strict manifest palette extraction support in `tools/shared/platformShell.js`:
+  - `tools.palette.payload` (preferred/canonical)
+  - `tools["palette-browser"].payload` (compatible)
+  - legacy `tools["palette-browser"].palette` and root `palette` as compatibility fallbacks
+- Added `hydrateSharedPaletteFromSamplePresetPath(samplePresetPath)`:
+  - Reads the full sample preset document (bypassing scoped fetch shim when present)
+  - Resolves palette from workspace manifest tools payload
+  - Writes shared palette handoff with source metadata
+- `resolveWorkspaceToolLockState()` now treats palette dependency as ready when either:
+  - shared palette handoff exists, or
+  - manifest palette payload resolves successfully
+
+Which buttons remain disabled and why, if any:
+- In shared shell navigation, no palette-dependent tool should remain disabled solely due to missing shared palette when sample 1902 palette payload exists.
+- Buttons can still be disabled when workspace is not ready/closed.
+- Utility tools may still show N/A asset/status labels by design where they are non-asset tools.
+
+Validation command results:
+- node --check tools/shared/platformShell.js -> PASS
+- node ./tests/runtime/LaunchSmokeAllEntries.test.mjs --samples --sample-range=1902-1902 --tools -> PASS
+  - Summary: PASS=19 FAIL=0 TOTAL=19

docs/dev/reports/PR_11_28_validation_template.txt

@@ -0,0 +1,26 @@
+# PR 11.28 Validation
+
+Changed files:
+-
+
+Root cause:
+-
+
+Shared palette handoff:
+-
+
+Before:
+- Vector Map launch from Workspace Manager reported missing palette.
+
+After:
+- Vector Map launch resolves shared palette from sample 1902 workspace payload.
+
+Remaining disabled tools, if any:
+-
+
+Validation:
+- node --check tools/shared/platformShell.js
+- node ./tests/runtime/LaunchSmokeAllEntries.test.mjs --samples --sample-range=1902-1902 --tools
+
+Manual:
+- sample 1902 -> Workspace Manager -> Vector Map Editor opens without missing palette

docs/pr/PR_11_28_WORKSPACE_CHILD_TOOL_SHARED_PALETTE_HANDOFF.md

@@ -0,0 +1,47 @@
+# PR 11.28 — Workspace Child Tool Shared Palette Handoff
+
+## Purpose
+Fix the remaining Workspace Manager launch defect from the known-good `4dc2b0f` baseline: payload-backed tools can now be clicked, but opening Vector Map reports that its palette is missing.
+
+## Current State
+- Workspace Manager displays the full sample 1902 workspace.
+- Palette Browser and Vector Map are enabled.
+- Other tools remain grayed out.
+- Opening Vector Map fails because the child tool launch does not receive or resolve the shared workspace palette.
+
+## Required Change
+Make Workspace Manager child tool launches carry or resolve the shared palette payload from the same embedded workspace manifest that is already loaded for sample 1902.
+
+## Scope
+- Keep `4dc2b0f` as the baseline.
+- Preserve full workspace display.
+- Preserve embedded payload status labels.
+- Do not reapply failed PR 11.23/11.25 palette-only logic.
+- Do not add hardcoded palette data.
+- Do not add hidden/default fallback samples.
+- Do not require external asset files.
+- Do not touch start_of_day folders.
+- Keep the fix surgical.
+
+## Key Rule
+A workspace tool launch must receive the payload it depends on from the explicit sample-owned workspace JSON.
+
+For palette-dependent tools:
+- shared palette data may come from `manifest.tools.palette`
+- tool-specific payload may come from `manifest.tools[toolId]`
+- launch should provide both when the tool requires palette context
+
+## Investigation Targets
+- child tool launch URL/context builder
+- scoped preset/payload handoff
+- palette readiness detection
+- tool dependency resolution
+- disabled-state logic for tools that are grayed out because shared palette is not being handed off
+
+## Acceptance
+- Opening Vector Map from Workspace Manager no longer says palette is missing.
+- Vector Map opens with the sample 1902 shared palette context.
+- Payload-backed tools that depend on the shared palette are enabled/openable when palette payload exists.
+- Workspace Manager still shows full workspace, not palette-only.
+- No tool is enabled using fake/hidden fallback data.
+- Smoke test passes.

tools/shared/platformShell.js

@@ -1238,16 +1238,25 @@ function readPaletteFromManifestPayload(manifestPayload, launchContext = null) {
   const tools = source.tools && typeof source.tools === "object" && !Array.isArray(source.tools)
     ? source.tools
     : {};
+  const paletteToolSection = tools.palette && typeof tools.palette === "object" && !Array.isArray(tools.palette)
+    ? tools.palette
+    : null;
   const paletteBrowserSection = tools["palette-browser"] && typeof tools["palette-browser"] === "object" && !Array.isArray(tools["palette-browser"])
     ? tools["palette-browser"]
     : null;
-  const preferredPalette = paletteBrowserSection?.palette && typeof paletteBrowserSection.palette === "object" && !Array.isArray(paletteBrowserSection.palette)
+  const paletteToolPayload = paletteToolSection?.payload && typeof paletteToolSection.payload === "object" && !Array.isArray(paletteToolSection.payload)
+    ? paletteToolSection.payload
+    : null;
+  const paletteBrowserPayload = paletteBrowserSection?.payload && typeof paletteBrowserSection.payload === "object" && !Array.isArray(paletteBrowserSection.payload)
+    ? paletteBrowserSection.payload
+    : null;
+  const paletteBrowserLegacyPalette = paletteBrowserSection?.palette && typeof paletteBrowserSection.palette === "object" && !Array.isArray(paletteBrowserSection.palette)
     ? paletteBrowserSection.palette
     : null;
   const compatibilityRootPalette = source.palette && typeof source.palette === "object" && !Array.isArray(source.palette)
     ? source.palette
     : null;
-  const selectedPalette = preferredPalette || compatibilityRootPalette;
+  const selectedPalette = paletteToolPayload || paletteBrowserPayload || paletteBrowserLegacyPalette || compatibilityRootPalette;
   if (!selectedPalette) {
     return null;
   }
@@ -1263,12 +1272,55 @@ function readPaletteFromManifestPayload(manifestPayload, launchContext = null) {
   if (!normalized) {
     return null;
   }
+  let sourceKey = "workspace-game-manifest.root-palette-compat";
+  if (paletteToolPayload) {
+    sourceKey = "workspace-game-manifest.tools.palette.payload";
+  } else if (paletteBrowserPayload) {
+    sourceKey = "workspace-game-manifest.palette-browser.payload";
+  } else if (paletteBrowserLegacyPalette) {
+    sourceKey = "workspace-game-manifest.palette-browser";
+  }
   return {
     ...normalized,
-    source: preferredPalette ? "workspace-game-manifest.palette-browser" : "workspace-game-manifest.root-palette-compat"
+    source: sourceKey
   };
 }
 
+async function hydrateSharedPaletteFromSamplePresetPath(samplePresetPath = "") {
+  const normalizedSamplePresetPath = normalizeSamplePresetPath(samplePresetPath);
+  if (!normalizedSamplePresetPath || typeof window === "undefined" || typeof window.fetch !== "function") {
+    return false;
+  }
+  const fetchImpl = window.fetch.__workspaceScopedSamplePresetOriginalFetch || window.fetch.bind(window);
+  try {
+    const response = await fetchImpl(normalizedSamplePresetPath, { cache: "no-store" });
+    if (!response.ok) {
+      return false;
+    }
+    const samplePreset = await response.json();
+    if (!isWorkspaceManifestPreset(samplePreset)) {
+      return false;
+    }
+    const manifestPalette = readPaletteFromManifestPayload(samplePreset, null);
+    if (!manifestPalette) {
+      return false;
+    }
+    return writeSharedPaletteHandoff({
+      paletteId: manifestPalette.paletteId,
+      displayName: manifestPalette.displayName,
+      colors: manifestPalette.colors,
+      metadata: {
+        source: manifestPalette.source,
+        sourcePath: normalizedSamplePresetPath
+      },
+      sourceToolId: "workspace-manager",
+      selectedAt: new Date().toISOString()
+    });
+  } catch {
+    return false;
+  }
+}
+
 async function hydrateSharedPaletteFromGameLaunchContext(catalogContext = null) {
   const launchContext = catalogContext?.launchContext || readGameLaunchContext();
   if (!launchContext?.gameId && !launchContext?.gameHref) {
@@ -1512,7 +1564,11 @@ function resolveWorkspaceToolLockState() {
   const manifest = getManifest();
   const palette = readSharedPaletteHandoff();
   const workspaceReady = Boolean(manifest && manifest.workspace?.notes !== "closed");
-  const paletteReady = Boolean(palette && typeof palette.displayName === "string" && palette.displayName.trim());
+  const manifestPalette = readPaletteFromManifestPayload(manifest, null);
+  const paletteReady = Boolean(
+    (palette && typeof palette.displayName === "string" && palette.displayName.trim())
+    || manifestPalette
+  );
   const hasToolState = (toolId) => {
     const normalizedToolId = normalizeTextValue(toolId);
     if (!normalizedToolId || !manifest || typeof manifest !== "object") {
@@ -2248,6 +2304,7 @@ async function initPlatformShell() {
   const clearedForLaunch = clearSharedBindingsForNewLaunch(launchSignature);
   const launchContext = readGameLaunchContext();
   const launchedFromSamplePreset = Boolean(samplePresetPath);
+  const hydratedSamplePresetPalette = await hydrateSharedPaletteFromSamplePresetPath(samplePresetPath);
 
   if (currentToolId) {
     workspaceController = createWorkspaceSystemController({
@@ -2299,6 +2356,9 @@ async function initPlatformShell() {
   if (hydratedPalette) {
     TOOLS_PLATFORM_LOGGER.debug("shared palette hydrated from game asset catalog");
   }
+  if (hydratedSamplePresetPalette) {
+    TOOLS_PLATFORM_LOGGER.debug("shared palette hydrated from sample workspace manifest");
+  }
   bindLiveBindingRefresh(currentTool);
 }