@chainingintention/pi-web-cn 1.202610.4 → 2.202610.0

package/dist/pi-web-plugins/git/browser/git-panel.js

@@ -17,13 +17,13 @@ const GIT_WORKSPACE_STATE_LIMIT = 8;
 const activityElementTag = "pi-web-git-panel-activity";
 const EMPTY_LIST_MODEL = { submodules: [], files: [] };
 const EMPTY_VIEW_STATE = { nodes: [], listModel: EMPTY_LIST_MODEL, expandablePaths: [] };
-export function createGitBrowserContributions(sourcePluginId, runtimePluginId, html, svg) {
+export function createGitBrowserContributions(sourcePluginId, runtimePluginId, html, svg, stylesheetIntegration = () => undefined) {
     const panelId = `${runtimePluginId}:${GIT_PANEL_LOCAL_ID}`;
     const controller = new GitUiController(sourcePluginId, createGitDiffRoute(panelId));
     defineGitPanelActivityElement();
     return {
         actions: createGitActions(panelId, controller),
-        workspacePanels: [createGitPanel(html, svg, controller)],
+        workspacePanels: [createGitPanel(html, svg, controller, stylesheetIntegration)],
     };
 }
 class GitUiController {
@@ -38,8 +38,8 @@ class GitUiController {
         this.sourcePluginId = sourcePluginId;
         this.route = route;
     }
-    isOwnedWorkspace(workspace) {
-        return workspace?.provider?.pluginId === this.sourcePluginId;
+    canInspectWorkspace(workspace) {
+        return workspace !== undefined && (workspace.provider === undefined || workspace.provider.pluginId === this.sourcePluginId);
     }
     state(context) {
         return this.stateFor(context);
@@ -83,7 +83,7 @@ class GitUiController {
         void this.refresh(context, false);
     }
     invalidate(context) {
-        if (!this.isOwnedWorkspace(context.workspace))
+        if (!this.canInspectWorkspace(context.workspace))
             return Promise.resolve();
         const state = this.stateFor(context);
         state.stale = state.status !== undefined;
@@ -336,7 +336,7 @@ class GitUiController {
     }
 }
 function createGitActions(panelId, controller) {
-    const hasGitWorkspace = (context) => controller.isOwnedWorkspace(context.state.selectedWorkspace);
+    const hasGitWorkspace = (context) => controller.canInspectWorkspace(context.state.selectedWorkspace);
     return [
         {
             id: "view.git",
@@ -358,7 +358,7 @@ function createGitActions(panelId, controller) {
         },
     ];
 }
-function createGitPanel(html, svg, controller) {
+function createGitPanel(html, svg, controller, stylesheetIntegration) {
     return {
         id: GIT_PANEL_LOCAL_ID,
         title: "Git",
@@ -375,9 +375,9 @@ function createGitPanel(html, svg, controller) {
         order: 20,
         routeAliases: ["git", "core:workspace.git"],
         navigationAliases: ["core:workspace.git"],
-        visible: (context) => controller.isOwnedWorkspace(context.workspace),
+        visible: (context) => controller.canInspectWorkspace(context.workspace),
         onInvalidate: (context) => controller.invalidate(context),
-        render: (context) => renderGitPanel(html, controller, context),
+        render: (context) => renderGitPanel(html, controller, context, stylesheetIntegration()),
     };
 }
 function requestGitBackend(context, operation, input) {
@@ -386,26 +386,26 @@ function requestGitBackend(context, operation, input) {
     }
     return context.peer.request(operation, input);
 }
-function renderGitPanel(html, controller, context) {
+function renderGitPanel(html, controller, context, stylesheetIntegration) {
     const state = controller.state(context);
     const viewState = controller.viewState(state);
     return html `
     <section class="git-panel">
-      <style .textContent=${gitPanelStyles}></style>
-      <pi-web-git-panel-activity .controller=${controller} .context=${context}></pi-web-git-panel-activity>
-      <section class="git-toolbar">
+      <style data-git-styles .textContent=${gitPanelStyles}></style>
+      <pi-web-git-panel-activity .stylesheetIntegration=${stylesheetIntegration} .controller=${controller} .context=${context}></pi-web-git-panel-activity>
+      <section class="ui-toolbar git-toolbar">
         <strong>Git</strong>
         ${state.stale ? html `<span class="git-stale">${t("ui.main.3468df3f1fe9", "stale")}</span>` : null}
-        <div class="git-toolbar-actions">
+        <div class="ui-toolbar-group git-toolbar-actions">
           ${viewState.expandablePaths.length === 0 ? null : renderExpandCollapseAll(html, controller, context, state, viewState.expandablePaths)}
           ${renderViewToggle(html, controller, context)}
-          <button type="button" ?disabled=${state.statusLoading} @click=${() => { void controller.refresh(context); }}>${t("bundled.relays.refresh.aee887", "Refresh")}</button>
+          <button class="ui-button" type="button" ?disabled=${state.statusLoading} @click=${() => { void controller.refresh(context); }}>${t("bundled.relays.refresh.aee887", "Refresh")}</button>
         </div>
       </section>
       ${state.error === undefined ? null : html `<div class="git-error" role="alert">${state.error}</div>`}
       ${state.status?.truncated === true ? html `<div class="git-warning" role="status">${t("ui.main.1634590c49b8", "Git status output was too large; the file list was truncated.")}</div>` : null}
       <section class="git-split">
-        <div class="git-file-list">${renderFileList(html, controller, context, state, viewState)}</div>
+        <div class="ui-file-list git-file-list">${renderFileList(html, controller, context, state, viewState)}</div>
         <div class="git-viewer">${renderDiffViewer(html, state)}</div>
       </section>
     </section>
@@ -413,7 +413,7 @@ function renderGitPanel(html, controller, context) {
 }
 function renderViewToggle(html, controller, context) {
     return html `
-    <div class="git-view-toggle" role="group" aria-label="${t("ui.main.898449210b9d", "Changed files view")}">
+    <div class="ui-toolbar-group git-view-toggle" role="group" aria-label="${t("ui.main.898449210b9d", "Changed files view")}">
       ${renderViewToggleButton(html, controller, context, "list", t("ui.workspaceGitPanel.list", "List"))}
       ${renderViewToggleButton(html, controller, context, "tree", t("ui.main.7f32c63d2d35", "Tree"))}
     </div>
@@ -421,11 +421,11 @@ function renderViewToggle(html, controller, context) {
 }
 function renderViewToggleButton(html, controller, context, view, label) {
     const active = controller.currentView() === view;
-    return html `<button type="button" class=${active ? "is-selected" : ""} aria-pressed=${String(active)} @click=${() => { controller.setView(context, view); }}>${label}</button>`;
+    return html `<button type="button" class="ui-button" aria-pressed=${String(active)} @click=${() => { controller.setView(context, view); }}>${label}</button>`;
 }
 function renderExpandCollapseAll(html, controller, context, state, expandablePaths) {
     const allExpanded = expandablePaths.every((path) => state.expandedDirectories.has(path));
-    return html `<button type="button" @click=${() => { controller.toggleExpandAll(context, expandablePaths, allExpanded); }}>${allExpanded ? t("ui.workspaceGitPanel.collapseAll", "Collapse all") : t("ui.workspaceGitPanel.expandAll", "Expand all")}</button>`;
+    return html `<button class="ui-button" type="button" @click=${() => { controller.toggleExpandAll(context, expandablePaths, allExpanded); }}>${allExpanded ? t("ui.workspaceGitPanel.collapseAll", "Collapse all") : t("ui.workspaceGitPanel.expandAll", "Expand all")}</button>`;
 }
 function renderFileList(html, controller, context, state, viewState) {
     const status = state.status;
@@ -458,9 +458,9 @@ function renderSubmoduleGroup(html, controller, context, state, group) {
         return html ``;
     const expanded = state.expandedDirectories.has(group.path);
     return html `
-    <button type="button" class="git-row" style="--depth:0" aria-expanded=${String(expanded)} @click=${() => { controller.toggleDirectory(context, group.path); }}>
-      <span class="git-twisty">${expanded ? "▾" : "▸"}</span>
-      <span>${group.name}${submoduleBadge(html)}</span>
+    <button type="button" class="ui-button ui-file-row" style="--depth:0" title=${group.path} aria-expanded=${String(expanded)} @click=${() => { controller.toggleDirectory(context, group.path); }}>
+      <span class="ui-file-leading" aria-hidden="true">${expanded ? "▾" : "▸"}</span>
+      <span class="ui-file-label">${group.name}${submoduleBadge(html)}</span>
     </button>
     ${expanded ? html `
       ${group.pointer === undefined ? null : renderSelectableRow(html, controller, context, state, group.path, group.pointer.name, group.pointer.file, 1)}
@@ -477,9 +477,9 @@ function renderTreeNode(html, controller, context, state, node, depth) {
             return html ``;
         const expanded = state.expandedDirectories.has(node.path);
         return html `
-      <button type="button" class="git-row" style=${`--depth:${String(depth)}`} aria-expanded=${String(expanded)} @click=${() => { controller.toggleDirectory(context, node.path); }}>
-        <span class="git-twisty">${expanded ? "▾" : "▸"}</span>
-        <span>${node.name}${node.isSubmodule === true ? submoduleBadge(html) : null}</span>
+      <button type="button" class="ui-button ui-file-row" style=${`--depth:${String(depth)}`} title=${node.path} aria-expanded=${String(expanded)} @click=${() => { controller.toggleDirectory(context, node.path); }}>
+        <span class="ui-file-leading" aria-hidden="true">${expanded ? "▾" : "▸"}</span>
+        <span class="ui-file-label">${node.name}${node.isSubmodule === true ? submoduleBadge(html) : null}</span>
       </button>
       ${expanded ? node.children.map((child) => renderTreeNode(html, controller, context, state, child, depth + 1)) : null}
     `;
@@ -494,9 +494,10 @@ function renderSelectableRow(html, controller, context, state, path, label, file
         return html ``;
     const selected = state.selectedDiffPath === path;
     return html `
-    <button type="button" class=${selected ? "git-row is-selected" : "git-row"} style=${`--depth:${String(depth)}`} @click=${() => { controller.selectDiff(context, path); }}>
-      <span>${stateLabel(file.index, file.workingTree)}</span>
-      <span>${label}</span>
+    <button type="button" class=${selected ? "ui-button ui-file-row selected" : "ui-button ui-file-row"} style=${`--depth:${String(depth)}`} title=${path} aria-current=${selected ? "page" : "false"} @click=${() => { controller.selectDiff(context, path); }}>
+      <span class="ui-file-leading" aria-hidden="true"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8Z"></path><path d="M14 2v6h6"></path></svg></span>
+      <span class="ui-file-label">${label}</span>
+      <span class="ui-file-meta">${stateLabel(file.index, file.workingTree)}</span>
     </button>
   `;
 }
@@ -591,6 +592,24 @@ function defineGitPanelActivityElement() {
         controllerValue;
         contextValue;
         pollTimer;
+        integration;
+        releaseStyles;
+        set stylesheetIntegration(value) {
+            if (this.integration === value)
+                return;
+            this.releaseStyles?.();
+            this.releaseStyles = undefined;
+            this.integration = value;
+            this.registerStyles();
+        }
+        registerStyles() {
+            if (!this.isConnected || this.releaseStyles !== undefined)
+                return;
+            const root = this.getRootNode();
+            // The activity element shares the host panel's root; it owns only this opt-in.
+            if (root instanceof ShadowRoot)
+                this.releaseStyles = this.integration?.registerRoot(root, { sharedUi: true });
+        }
         set controller(value) {
             if (this.controllerValue === value)
                 return;
@@ -604,11 +623,14 @@ function defineGitPanelActivityElement() {
                 this.restart();
         }
         connectedCallback() {
+            this.registerStyles();
             window.addEventListener("popstate", this.onPopState);
             document.addEventListener("visibilitychange", this.onVisibilityChange);
             this.restart();
         }
         disconnectedCallback() {
+            this.releaseStyles?.();
+            this.releaseStyles = undefined;
             window.removeEventListener("popstate", this.onPopState);
             document.removeEventListener("visibilitychange", this.onVisibilityChange);
             if (this.controllerValue !== undefined && this.contextValue !== undefined)
@@ -675,30 +697,22 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 const gitPanelStyles = `
-  .git-panel { flex: 1 1 auto; min-height: 0; display: flex; flex-direction: column; overflow: hidden; color: var(--pi-text); background: var(--pi-bg); font: 13px system-ui, sans-serif; }
+  .git-panel { flex: 1 1 auto; min-height: 0; display: flex; flex-direction: column; overflow: hidden; color: var(--pi-text); background: var(--pi-bg); font: 13px var(--pi-font, system-ui, sans-serif); }
   .git-panel ${activityElementTag} { display: none; }
-  .git-panel button { display: inline-flex; align-items: center; gap: 5px; border: 1px solid var(--pi-border); border-radius: 7px; background: var(--pi-surface); color: var(--pi-text); padding: 5px 7px; cursor: pointer; }
-  .git-panel button:disabled { cursor: wait; opacity: .65; }
   .git-panel small, .git-panel .git-muted { color: var(--pi-muted); }
   .git-panel p { margin: 10px; }
-  .git-panel .git-toolbar { flex: 0 0 auto; display: flex; align-items: center; gap: 8px; padding: 8px; border-bottom: 1px solid var(--pi-border-muted); }
-  .git-panel .git-toolbar-actions { display: flex; align-items: center; gap: 8px; margin-left: auto; }
-  .git-panel .git-view-toggle { display: inline-flex; }
-  .git-panel .git-view-toggle button { border-radius: 0; }
-  .git-panel .git-view-toggle button:first-child { border-top-left-radius: 7px; border-bottom-left-radius: 7px; }
-  .git-panel .git-view-toggle button:last-child { margin-left: -1px; border-top-right-radius: 7px; border-bottom-right-radius: 7px; }
-  .git-panel .git-view-toggle button.is-selected { position: relative; z-index: 1; border-color: var(--pi-accent); background: var(--pi-selection-bg); }
-  .git-panel .git-stale { border: 1px solid var(--pi-warning-border); border-radius: 999px; color: var(--pi-warning); padding: 1px 6px; font-size: 12px; }
+  .git-panel .git-toolbar { flex: 0 0 auto; border-bottom: 1px solid var(--pi-border-muted); font-size: 12px; color: var(--pi-muted); }
+  .git-panel .git-toolbar-actions { margin-left: auto; }
+  .git-panel .git-toolbar > strong { display: flex; align-items: center; padding-inline: 10px; font-weight: 500; }
+  .git-panel .git-toolbar .ui-button { white-space: nowrap; }
+  .git-panel .git-toolbar .ui-button[aria-pressed="true"] { background: var(--pi-surface-hover); color: var(--pi-text); }
+  .git-panel .git-stale { border: 1px solid var(--pi-warning-border); border-radius: 999px; color: var(--pi-warning); padding: 1px 6px; font-size: 12px; align-self: center; }
   .git-panel .git-error { flex: 0 0 auto; margin: 8px; border: 1px solid var(--pi-danger); border-radius: 7px; color: var(--pi-danger); padding: 8px; }
   .git-panel .git-warning { flex: 0 0 auto; margin: 8px; border: 1px solid var(--pi-warning-border); border-radius: 7px; color: var(--pi-warning); padding: 8px; }
   .git-panel .git-load-more { margin: 8px auto; }
   .git-panel .git-split { flex: 1 1 auto; min-height: 0; display: grid; grid-template-rows: minmax(160px, 34%) minmax(0, 1fr); }
-  .git-panel .git-file-list { min-height: 0; overflow: auto; border-bottom: 1px solid var(--pi-border); padding: 6px; }
-  .git-panel .git-row { display: grid; grid-template-columns: 18px minmax(0, 1fr); gap: 4px; width: 100%; border: 0; border-radius: 5px; background: transparent; text-align: left; padding: 4px 6px 4px calc(6px + var(--depth, 0) * 14px); }
-  .git-panel .git-row:hover, .git-panel .git-row.is-selected { background: var(--pi-selection-bg); }
-  .git-panel .git-row span:last-child { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-  .git-panel .git-twisty { color: var(--pi-dim, var(--pi-muted)); }
-  .git-panel .git-summary { margin: 4px 6px 8px; color: var(--pi-muted); }
+  .git-panel .git-file-list { border-bottom: 1px solid var(--pi-border); }
+  .git-panel .git-summary { margin: 10px 12px 8px; color: var(--pi-muted); }
   .git-panel .submodule-badge { display: inline-block; margin-left: 6px; border: 1px solid var(--pi-border); border-radius: 999px; color: var(--pi-muted); padding: 0 5px; font-size: 11px; font-weight: 400; vertical-align: baseline; }
   .git-panel .git-viewer { min-height: 0; overflow: auto; display: flex; flex-direction: column; }
   .git-panel .git-diffs { flex: 1 1 auto; min-height: 0; overflow: auto; display: grid; grid-template-rows: minmax(120px, 1fr) minmax(120px, 1fr); }
@@ -708,7 +722,7 @@ const gitPanelStyles = `
   .git-panel .git-viewer-header { position: sticky; top: 0; display: flex; justify-content: space-between; gap: 8px; padding: 8px; border-bottom: 1px solid var(--pi-border-muted); background: var(--pi-bg); }
   .git-panel .git-viewer-header strong { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
   .git-panel .git-diff-scroller { flex: 1 1 auto; min-height: 0; overflow: auto; background: var(--pi-bg); }
-  .git-panel .git-diff-grid { display: grid; grid-template-columns: max-content max-content 2ch max-content; width: max-content; min-width: 100%; padding: 6px 0; font: 12px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; line-height: 1.45; }
+  .git-panel .git-diff-grid { display: grid; grid-template-columns: max-content max-content 2ch max-content; width: max-content; min-width: 100%; padding: 6px 0; font: 12px var(--pi-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace); line-height: 1.45; }
   .git-panel .git-diff-line { display: contents; }
   .git-panel .git-diff-cell { min-height: 1.45em; white-space: pre; }
   .git-panel .git-line-number { min-width: 4ch; padding: 0 8px; border-right: 1px solid var(--pi-border-muted); color: var(--pi-dim); text-align: right; user-select: none; }

package/dist/pi-web-plugins/git/browser/pi-web-plugin.js

@@ -1,14 +1,34 @@
 // Generated from pi-web-plugins/git/browser/pi-web-plugin.ts. Do not edit directly.
 import { setTranslator } from "./i18n.js";
 import { createGitBrowserContributions } from "./git-panel.js";
+const stylesheetIntegrationCapability = {
+    pluginId: "pi-web", id: "stylesheet-integration", version: 1,
+    parse: (value) => {
+        if (!isStylesheetIntegration(value)) {
+            throw new Error("Invalid PI WEB stylesheet integration capability v1");
+        }
+        return value;
+    },
+};
+function isStylesheetIntegration(value) {
+    return typeof value === "object" && value !== null
+        && "registerRoot" in value && typeof value.registerRoot === "function"
+        && "subscribe" in value && typeof value.subscribe === "function"
+        && "createController" in value && typeof value.createController === "function";
+}
 const plugin = {
     apiVersion: 4,
     name: "Git",
+    requires: [stylesheetIntegrationCapability],
     activate: ({ pluginId, runtimePluginId, html, svg, translate }) => {
         setTranslator(translate);
-        return ({
-            contributions: createGitBrowserContributions(pluginId, runtimePluginId, html, svg),
-        });
+        let stylesheetIntegration;
+        return {
+            start: ({ capabilities }) => {
+                stylesheetIntegration = capabilities.resolve(stylesheetIntegrationCapability);
+            },
+            contributions: createGitBrowserContributions(pluginId, runtimePluginId, html, svg, () => stylesheetIntegration),
+        };
     },
 };
 export default plugin;

package/dist/pi-web-plugins/git/git-backend.js

@@ -11,11 +11,19 @@ const statusCaches = new WeakMap();
 const GIT_LOCAL_ENV_VARS = Object.freeze([
     "GIT_ALTERNATE_OBJECT_DIRECTORIES",
     "GIT_COMMON_DIR",
+    "GIT_CONFIG",
+    "GIT_CONFIG_COUNT",
+    "GIT_CONFIG_PARAMETERS",
     "GIT_DIR",
+    "GIT_GRAFT_FILE",
+    "GIT_IMPLICIT_WORK_TREE",
     "GIT_INDEX_FILE",
+    "GIT_NO_REPLACE_OBJECTS",
     "GIT_OBJECT_DIRECTORY",
     "GIT_PREFIX",
     "GIT_QUARANTINE_PATH",
+    "GIT_REPLACE_REF_BASE",
+    "GIT_SHALLOW_FILE",
     "GIT_WORK_TREE",
 ]);
 /** Dispatch the Git status/diff schema through the package peer request seam. */
@@ -44,7 +52,7 @@ async function gitStatusWithRunner(runGit, cwd) {
     if (result.code !== 0)
         return { isGitRepo: false, hash: hash(result.stdout + result.stderr), files: [], submodules: [], ...(result.truncated ? { truncated: true } : {}) };
     const parsed = parseStatus(result.truncated ? result.stdout.slice(0, result.stdout.lastIndexOf("\0") + 1) : result.stdout, { deferSubmodules: true });
-    return expandSubmodules(runGit, cwd, parsed, result.stdout, result.truncated);
+    return expandSubmodules(runGit, await gitWorktreeRoot(runGit, cwd), parsed, result.stdout, result.truncated);
 }
 /**
  * Merge each dirty submodule's own changes into the flat file list. A moved
@@ -136,6 +144,8 @@ async function gitDiffWithRunner(runGit, cwd, options) {
     let path;
     if (options.path !== undefined && options.path !== "")
         path = normalizeRelativePath(options.path);
+    // Diff/status paths belong to the repository, not a folder project's session cwd.
+    cwd = await gitWorktreeRoot(runGit, cwd);
     if (path !== undefined) {
         const owner = await submoduleForPath(runGit, cwd, path);
         if (owner !== undefined)
@@ -181,6 +191,15 @@ async function submoduleDiff(runGit, owner, path, staged) {
     }
     return { path, staged, hash: hash(result.stdout), diff: result.stdout, truncated: result.truncated };
 }
+async function gitWorktreeRoot(runGit, cwd) {
+    const result = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    if (result.code !== 0)
+        throw new Error(result.stderr.trim() || t("git.cwdRootUnavailable", "Cannot resolve Git worktree root"));
+    const root = result.stdout.replace(/\r?\n$/u, "");
+    if (!isAbsolute(root))
+        throw new Error(t("git.cwdRootInvalid", "Git returned an invalid worktree root"));
+    return root;
+}
 async function isUntracked(runGit, cwd, path) {
     const result = await runGit(cwd, ["ls-files", "--others", "--exclude-standard", "-z", "--", path]);
     return result.code === 0 && result.stdout.split("\0").includes(path);

package/dist/pi-web-plugins/git/server-plugin.js

@@ -2,14 +2,23 @@
 import { t, setTranslator } from "./i18n.js";
 import { basename, resolve } from "node:path";
 import { requestGitBackend } from "./git-backend.js";
+import { createWorkspaceDiscoveryHooks } from "./workspaceDiscoveryHooks.js";
 const GIT_LOCAL_ENV_VARS = Object.freeze([
     "GIT_ALTERNATE_OBJECT_DIRECTORIES",
     "GIT_COMMON_DIR",
+    "GIT_CONFIG",
+    "GIT_CONFIG_COUNT",
+    "GIT_CONFIG_PARAMETERS",
     "GIT_DIR",
+    "GIT_GRAFT_FILE",
+    "GIT_IMPLICIT_WORK_TREE",
     "GIT_INDEX_FILE",
+    "GIT_NO_REPLACE_OBJECTS",
     "GIT_OBJECT_DIRECTORY",
     "GIT_PREFIX",
     "GIT_QUARANTINE_PATH",
+    "GIT_REPLACE_REF_BASE",
+    "GIT_SHALLOW_FILE",
     "GIT_WORK_TREE",
 ]);
 const plugin = {
@@ -18,22 +27,29 @@ const plugin = {
     activate(context) {
         setTranslator(context.translate);
         return {
-            workspaceProvider: createGitWorkspaceProvider(context),
+            workspaceProvider: createGitWorkspaceProvider(context, process.env["PI_WEB_INSTANCE_NAMESPACE"] ?? ""),
             peer: { request: (request) => requestGitBackend(context, request) },
         };
     },
 };
 export default plugin;
-export function createGitWorkspaceProvider(context) {
+export function createGitWorkspaceProvider(context, instanceNamespace = "") {
     return Object.freeze({
         fallback: true,
+        integration: createWorkspaceDiscoveryHooks(context, (cwd, args, signal) => runGit(context, cwd, args, signal), process.execPath, instanceNamespace),
         async probe(project, signal) {
             const result = await runGit(context, project.path, ["rev-parse", "--is-inside-work-tree"], signal);
             if (result.signal !== null)
                 throw new Error(t("ui.main.8919cbc9c0bd", "Git repository probe ended with signal {arg0}", { arg0: result.signal }));
             if (result.exitCode !== 0)
                 return "pass";
-            return result.stdout.trim() === "true" ? "claim" : "pass";
+            if (result.stdout.trim() !== "true")
+                return "pass";
+            const root = await requireGit(runGit(context, project.path, ["rev-parse", "--show-toplevel"], signal), t("ui.main.49c35c822771", "resolve the Git worktree root"));
+            if (root.stdout.trim() === "")
+                throw new Error(t("ui.main.f1639c9e2fd7", "Git returned an empty worktree root"));
+            // A folder project keeps its cwd; only checkout roots own worktree discovery.
+            return resolve(root.stdout.trim()) === resolve(project.path) ? "claim" : "pass";
         },
         async list(project, signal) {
             const rootResult = await requireGit(runGit(context, project.path, ["rev-parse", "--show-toplevel"], signal), t("ui.main.49c35c822771", "resolve the Git worktree root"));
@@ -163,6 +179,7 @@ async function runGit(context, cwd, args, signal) {
         file: "git",
         args: ["-C", cwd, ...args],
         unsetEnv: GIT_LOCAL_ENV_VARS,
+        timeoutMs: 10_000,
         signal,
     });
     if (result.stdoutTruncated || result.stderrTruncated) {

package/dist/pi-web-plugins/git/workspace-discovery-notify.cjs

@@ -0,0 +1,14 @@
+// Packaged with PI WEB: best-effort discovery hint, never Git authority.
+const { spawnSync } = require("node:child_process");
+const [notification, ...args] = process.argv.slice(2);
+
+// Initial worktree checkout has a null previous OID and branch flag 1.
+// --no-checkout skips this hook; ordinary catalog access still discovers it.
+if (args.length === 3 && /^(?:0{40}|0{64})$/.test(args[0]) && args[2] === "1") {
+  try {
+    const command = JSON.parse(notification);
+    if (Array.isArray(command) && command.length > 0 && command.every((value) => typeof value === "string")) {
+      spawnSync(command[0], command.slice(1), { stdio: "ignore", timeout: 2000, killSignal: "SIGKILL" });
+    }
+  } catch { /* Invalid arguments, missing commands, and daemon failures must not affect Git. */ }
+}

package/dist/pi-web-plugins/git/workspaceDiscoveryHooks.js

@@ -0,0 +1,186 @@
+// Generated from pi-web-plugins/git/workspaceDiscoveryHooks.ts. Do not edit directly.
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+const EVENT = "post-checkout";
+/** Git owns the hook policy; the host owns settings snapshots and notification attribution/transport. */
+export function createWorkspaceDiscoveryHooks(context, runGit, nodeExecutable = process.execPath, instanceNamespace = "") {
+    if (instanceNamespace !== "" && !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,31}$/u.test(instanceNamespace)) {
+        throw new Error("PI_WEB_INSTANCE_NAMESPACE must be 1–32 letters, digits, underscores or hyphens, starting with a letter or digit");
+    }
+    if (!isAbsolute(nodeExecutable))
+        throw new Error("Git hook runtime must be an absolute executable path");
+    // Serialize this activation's config edits, including registrations sharing a
+    // common Git config. Git itself locks writes from other processes.
+    let pending = Promise.resolve();
+    return Object.freeze({
+        reconcile(project, signal) {
+            const operation = pending.then(() => reconcile(project, signal));
+            pending = operation.catch(() => { });
+            return operation;
+        },
+        async acceptNotification(project, signal) {
+            return await enabled(project, signal) && (context.workspaceNotifications?.command(project.id).length ?? 0) > 0;
+        },
+    });
+    async function enabled(project, signal) {
+        signal.throwIfAborted();
+        const settings = context.resolveProjectSettings === undefined
+            ? context.settings
+            : await context.resolveProjectSettings(project, signal);
+        const value = settings["workspaceDiscoveryHooks"];
+        if (value === undefined)
+            return true;
+        if (typeof value !== "boolean")
+            throw new Error("Git setting workspaceDiscoveryHooks must be a boolean");
+        return value;
+    }
+    async function reconcile(project, signal) {
+        const isEnabled = await enabled(project, signal);
+        // Separate projects/instances may share Git config. This identity belongs
+        // to the packaged-helper implementation; older generated helpers are untouched.
+        const identity = createHash("sha256")
+            .update(JSON.stringify(["packaged-helper", context.pluginId, resolve(context.dataDirectory), project.id]))
+            .digest("hex");
+        // Keep the unnamespaced production identity byte-for-byte compatible.
+        // The name also scopes ownership records; never adopt another instance's hook.
+        const prefix = instanceNamespace === "" ? "" : `${instanceNamespace}-`;
+        const name = `pi-web-workspace-discovery-${prefix}${identity}`;
+        const helper = join(context.packageRoot, "workspace-discovery-notify.cjs");
+        const registration = join(context.dataDirectory, "workspace-discovery", `${name}.registration.json`);
+        const notifier = context.workspaceNotifications?.command(project.id);
+        const command = registrationCommand(helper, nodeExecutable, notifier ?? []);
+        const ownedCommands = new Set([command, ...await readRegistrationCommands(registration, signal)]);
+        const install = isEnabled && notifier !== undefined && notifier.length > 0;
+        if (install && !await supportsNamedHooks(project, signal))
+            return;
+        const commandKey = `hook.${name}.command`;
+        const eventKey = `hook.${name}.event`;
+        const commands = await readConfig(project, commandKey, signal);
+        const events = await readConfig(project, eventKey, signal);
+        if (commands.some((entry) => entry.scope !== "local" || !ownedCommands.has(entry.value))
+            || events.some((entry) => entry.scope !== "local" || (entry.value !== EVENT && commands.length === 0))) {
+            // We only install local keys. A same-name global/worktree registration is
+            // external even if its values happen to match ours; never override it or
+            // remove the local command on which its inherited event might depend.
+            throw new Error(`Git workspace discovery hook conflict: ${name} has unexpected configuration`);
+        }
+        if (!install) {
+            // Disconnect the event first: an event without a command makes Git fail.
+            // Installation uses the reverse order for the same reason.
+            await unsetLocal(project, eventKey, events, signal);
+            await unsetLocal(project, commandKey, commands, signal);
+            signal.throwIfAborted();
+            await rm(registration, { force: true });
+            return;
+        }
+        // Routing/runtime arguments live in Git config, not generated executable
+        // files. Preserve exact ownership before changing config, including either
+        // side of a failed update, then compact after installation succeeds.
+        await writeRegistration([...new Set([...commands.map((entry) => entry.value), command])]);
+        await setLocal(project, commandKey, command, commands, signal);
+        await setLocal(project, eventKey, EVENT, events, signal);
+        await writeRegistration([command]);
+        async function writeRegistration(owned) {
+            await writeOwnedFileIfChanged(registration, `${JSON.stringify({ version: 1, commands: owned })}\n`, signal);
+        }
+    }
+    async function supportsNamedHooks(project, signal) {
+        // Detect Git's advertised named-config facility, not its version. `hook
+        // list` is unsuitable here: a missing command in an existing registration
+        // makes it fail, preventing precisely the repair we need to perform.
+        const result = await runGit(project.path, ["help", "--config"], signal);
+        if (result.signal !== null)
+            throw new Error(`Git named-hook detection ended from signal ${result.signal}`);
+        const keys = result.stdout.split(/\r?\n/u);
+        const supported = result.exitCode === 0
+            && keys.includes("hook.<friendly-name>.command") && keys.includes("hook.<friendly-name>.event");
+        if (!supported)
+            context.logger.debug("Git named configuration hooks unavailable; workspace discovery remains on catalog access", { projectId: project.id });
+        return supported;
+    }
+    async function readConfig(project, key, signal) {
+        const result = await runGit(project.path, ["config", "--null", "--show-scope", "--get-all", key], signal);
+        if (result.signal === null && result.exitCode === 1)
+            return [];
+        requireSuccess(result, `read ${key}`);
+        const fields = result.stdout.split("\0");
+        if (fields.pop() !== "" || fields.length % 2 !== 0)
+            throw new Error(`Malformed Git config output for ${key}`);
+        const entries = [];
+        for (let index = 0; index < fields.length; index += 2) {
+            entries.push({ scope: fields[index] ?? "", value: fields[index + 1] ?? "" });
+        }
+        return entries;
+    }
+    async function setLocal(project, key, value, entries, signal) {
+        const local = entries.filter((entry) => entry.scope === "local");
+        if (local.length === 1 && local[0]?.value === value)
+            return;
+        requireSuccess(await runGit(project.path, ["config", "--local", "--replace-all", key, value], signal), `set ${key}`);
+    }
+    async function unsetLocal(project, key, entries, signal) {
+        if (!entries.some((entry) => entry.scope === "local"))
+            return;
+        requireSuccess(await runGit(project.path, ["config", "--local", "--unset-all", key], signal), `remove ${key}`);
+    }
+}
+function requireSuccess(result, action) {
+    if (result.signal === null && result.exitCode === 0)
+        return;
+    const outcome = result.signal === null ? `exit ${String(result.exitCode)}` : `signal ${result.signal}`;
+    throw new Error(`Unable to ${action} (${outcome}): ${result.stderr.trim()}`);
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function registrationCommand(helper, nodeExecutable, notificationCommand) {
+    // Git itself supplies the shell and appends quoted hook argv to the function
+    // call. No extra `sh` executable is required on the user's PATH. The final
+    // return preserves best-effort behavior even when our helper/runtime is gone.
+    const shellHelper = process.platform === "win32" ? helper.replaceAll("\\", "/") : helper;
+    const shellNode = process.platform === "win32" ? nodeExecutable.replaceAll("\\", "/") : nodeExecutable;
+    return `pi_web_workspace_notify () { if test -r ${shellQuote(shellHelper)}; then ${shellQuote(shellNode)} ${shellQuote(shellHelper)} ${shellQuote(JSON.stringify(notificationCommand))} "$@" >/dev/null 2>&1; fi; return 0; }; pi_web_workspace_notify`;
+}
+async function readRegistrationCommands(path, signal) {
+    let source;
+    try {
+        source = await readFile(path, { encoding: "utf8", signal });
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const value = JSON.parse(source);
+    if (typeof value !== "object" || value === null || Array.isArray(value)
+        || Reflect.get(value, "version") !== 1)
+        throw new Error(`Invalid PI WEB Git hook registration record: ${path}`);
+    const commands = Reflect.get(value, "commands");
+    if (!Array.isArray(commands) || !commands.every((command) => typeof command === "string" && command.length > 0)) {
+        throw new Error(`Invalid PI WEB Git hook command record: ${path}`);
+    }
+    return commands;
+}
+async function writeOwnedFileIfChanged(path, source, signal) {
+    signal.throwIfAborted();
+    try {
+        if (await readFile(path, { encoding: "utf8", signal }) === source)
+            return;
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
+            throw error;
+    }
+    await mkdir(dirname(path), { recursive: true });
+    // Atomic per-project ownership records never contain executable code.
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, source, { flag: "wx", mode: 0o600, signal });
+        signal.throwIfAborted();
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

package/dist/pi-web-plugins/info/infoInternals.js

@@ -210,7 +210,7 @@ function renderWorkspaceSection(html, workspace) {
     </section>
   `;
 }
-/** Panel body: render the Info tab for the current workspace panel context. */
+/** Panel body: machine status is useful even without a selected workspace. */
 export function renderInfoPanel(html, context) {
     return html `
     <style>
@@ -226,9 +226,9 @@ export function renderInfoPanel(html, context) {
     </style>
     <section class="toolbar"><strong>${t("bundled.info.info.e70286", "Info")}</strong></section>
     <section class="viewer info-status">
-      ${renderStatusSection(html, context.state?.piWebStatus)}
+      ${renderStatusSection(html, context.state.piWebStatus)}
       ${renderMachineSection(html, context.machine)}
-      ${renderWorkspaceSection(html, context.workspace)}
+      ${context.workspace === undefined ? null : renderWorkspaceSection(html, context.workspace)}
     </section>
   `;
 }

package/dist/pi-web-plugins/info/pi-web-plugin.js

@@ -24,7 +24,7 @@ const plugin = {
                         items: (context) => [{ type: "text", text: context.workspace.provider?.pluginId ?? (context.workspace.isGitRepo === true ? "Git" : t("bundled.info.folder.7c7802", "Folder")), title: context.workspace.path }],
                     },
                 ],
-                workspacePanels: [
+                applicationPanels: [
                     {
                         id: "workspace.info",
                         title: t("bundled.info.info.e70286", "Info"),