dsh-power-after-task 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to `dsh-power-after-task` are documented here.
+
+## 1.0.0
+
+Initial release.
+
+- Arm one Windows power action per session — `sleep`, `shutdown`, or `restart` — and run it when that session's task finishes.
+- Completion is the session's Agent going idle (`api-session/status`), so an error stop, a cancellation, or an archived session all count; any new activity puts the arm back to waiting.
+- Cancellable grace countdown between completion and the power command, defaulting to 45 seconds and capped at 1 hour.
+- Composer-dock control: one power icon that expands inline into Action and Grace drop-downs plus Arm; while armed it prints nothing but a smaller lit icon and Cancel.
+- Frame-wide countdown ribbon in `shell.overlay`: semi-transparent band, a large `m:ss.mmm` timer on animation frames, a tiny `Until sleep` / `Until shut down` / `Until restart` caption, and a Cancel button. Click-through everywhere else, so it never blocks the page.
+- The arm stays visible until the countdown runs successfully or you cancel it; a failed power command reports a `failed` state instead of silently returning to normal.
+- Enabling or disabling the plugin row adds or removes the dock entry live — the widget probes this package's route.
+- All colours come from `--dsw-alias-*` theme tokens, so the UI follows the Harness light/dark setting.
+- Plugin row ships `disabled: true`: enable it in Settings → Plugins when you need it.
+- Plugin-owned `/power-task` route. Mutating endpoints refuse a request that proves it is not the page — a non-loopback `Host`, a browser-reported cross-site `Sec-Fetch-Site`, or a non-loopback `Origin` — while accepting the page's own transport, which forwards `Cookie` but no fetch metadata. The route cannot run a power action immediately.
+- `GET /power-task/debug` reports sessions, origin, and the headers of the last read and mutating request, so a rejected Arm is diagnosable without a browser console.
+- `power_after_task` agent tool: `status`, `arm`, `cancel`, `execute`.
+- English and Persian locale dictionaries plus Plugin Manager title, description, and icon.
+- Local publish helper: `npm run publish:local` reads `NPM_TOKEN` from a gitignored `.env`, publishes through a throwaway owner-only npmrc, and deletes it afterwards.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mori
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,145 @@
-# Temporary Holding Version
+# dsh-power-after-task
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A DeepSeek Harness (DSH) plugin that puts the host Windows PC to **Sleep**, **Shuts it down**, or **Restarts** it once the current agent task finishes — with a cancellable grace countdown, controlled from one small button in the composer dock.
+
+It never acts on its own. Nothing happens until you press **Arm**, and the power command only runs after the session's agent has actually stopped working *and* the grace countdown has run out.
+
+**Repository:** <https://github.com/white-sparrow/dsh-power-after-task>
+
+## What counts as "the task finished"
+
+The task is the span of work between your prompt and the moment the agent stops producing work — however many steps (tool calls), turns, continuations, or subagents it took. It ends on any turn stop:
+
+| Situation | Treated as finished |
+| --- | --- |
+| The agent answered and stopped | yes |
+| The agent stopped with an error and showed no result | yes |
+| You cancelled the run | yes |
+| A goal driver or auto-continuation is still running the session | no |
+| You send another message while the countdown is running | no — the countdown goes back to waiting |
+| The session is archived or removed while armed | yes |
+
+The plugin watches the Harness session-status signal (`api-session/status`), so it follows the real agent lifecycle rather than a guess about "the answer being visible".
+
+## Arm and Grace
+
+- **Arm** — registers the request for one session: "when this session's task finishes, run the chosen power action". Until you Arm, the plugin is inert.
+- **Grace** — a cancellable delay between "the task finished" and "the command runs" (default 45 seconds). It exists so a mis-click, a late follow-up message, or unsaved work can still be rescued. Choices: 15s, 30s, 1m, 2m, 5m.
+- **Cancel** — stops the arm at any time, while waiting or while counting.
+
+```
+Arm → waiting for the task to finish → agent goes idle → grace countdown → power command
+        ↑ any new activity returns here                                   │ Cancel → off
+```
+
+Commands actually run: `shutdown.exe /s /t 0` (Shut down), `shutdown.exe /r /t 0` (Restart), or `kernel32!ApplicationSuspend` via PowerShell with a `rundll32 powrprof.dll,SetSuspendState 0,0,0` fallback (Sleep). Sleep uses `ApplicationSuspend` deliberately: the `rundll32` form hibernates whenever hibernation is enabled.
+
+## The control in the UI
+
+### Composer-dock control
+
+One entry in the composer dock, beside the shipped Activity and Usage entries:
+
+- **Idle** — a single power icon. Nothing else.
+- **Click** — expands inline into two drop-downs (Action, Grace) and an **Arm** button.
+- **Armed** — the icon shrinks, lights up (brand colour while waiting, amber while counting or failed), and a **Cancel** button appears. No status text is printed; hovering the icon shows the action and the remaining countdown.
+- **Disabled row** — the entry removes itself within a couple of seconds, whether you enable or disable it, because the widget probes the plugin route.
+
+### Countdown ribbon
+
+While a countdown is running, a wide semi-transparent ribbon sits across the middle of the frame (registered in `shell.overlay`):
+
+- A large `m:ss.mmm` timer — minutes, seconds, milliseconds — updated on animation frames.
+- A tiny line under it naming the target: `Until sleep`, `Until shut down`, `Until restart`.
+- A **Cancel** button, because the arm stays visible until the countdown finishes or you cancel it.
+
+The layer itself is click-through: only the Cancel button takes pointer events, so the ribbon never blocks the work you are still doing. A failed power command keeps the ribbon visible with the error instead of silently returning to normal.
+
+Every colour is a `--dsw-alias-*` theme token (`bg-overlay`, `brand-primary`, `state-warn-primary`, `state-error-primary`, `label-*`, `border-*`), mixed with `transparent` for the semi-transparent surfaces, so the plugin follows the Harness light/dark setting automatically.
+
+## Requirements
+
+- **Windows** host (the power commands are Windows-specific). On other platforms the action is rejected with an error.
+- **Web composition** (`dsh web`): the dock widget talks to the Host through this plugin's own HTTP route. A Desktop/Electron page has no `ctx.webServer`, so the control does not appear there.
+- Node 20+ for the Harness Host.
+
+## Install
+
+Publish or unpack the package, then install the bundle in the Harness profile:
+
+- **Plugin Manager UI** → Install bundle → `dsh-power-after-task`.
+- Or from an agent session, ask it to install the bundle with the `plugin_manager` tool.
+- Or from a checkout: `plugin_manager` install target pointing at the directory (pnpm links it, no build step — the package ships plain JavaScript).
+
+The bundle ships a composition patch (`dsh.bundle.patch`) that inserts the plugin row. Installing does **not** turn it on.
+
+## Enable it when you need it
+
+The row ships `disabled: true`, so after install nothing runs and the dock entry does not appear:
+
+1. Settings → Plugins → **Power after task** → enable. The entry appears within a couple of seconds, and disabling the row removes it again — no page refresh needed either way.
+
+Arm and Cancel are mutating, so they refuse a request that *proves* it is not this page: a non-loopback `Host` (DNS rebinding or a foreign vhost), a browser-reported cross-site request (`Sec-Fetch-Site`), or a non-loopback `Origin`. A request carrying none of that evidence is accepted — that is the Harness page through its own transport, which forwards `Cookie` but not `Sec-Fetch-*` or `Origin` — and a local process, which could run `shutdown.exe` directly anyway. A foreign web page cannot reach this port under its own name, and a DNS-rebinding attack arrives with the foreign `Host`, so both are refused. Turning the row off clears every pending arm and countdown.
+
+`GET /power-task/debug` reports the running and armed sessions, the server origin, and the headers of the last read plus the last mutating request (`accepted` says whether the guard passed), so a rejected Arm is diagnosable without a browser console.
+
+## Configuration
+
+The row's `config` lives in `cordis.patch.yml` inside the package; override it with your own patch if you want different defaults.
+
+| Field | Default | Meaning |
+| --- | --- | --- |
+| `defaultAction` | `shutdown` | Action the control preselects: `sleep`, `shutdown`, `restart` |
+| `graceSeconds` | `45` | Countdown length after the task finishes; capped at 3600 |
+
+## Agent tool
+
+The plugin also registers one tool, so you can ask your agent to do the same thing:
+
+`power_after_task` — `action: status | arm | cancel | execute`, `session`, `power: sleep | shutdown | restart`, `grace_seconds`.
+
+`execute` runs the action immediately and is deliberately **not** reachable from the HTTP route: the page can only Arm and Cancel.
+
+## Files
+
+| File | Role |
+| --- | --- |
+| `index.js` | Host half: `/power-task` route, session-status watcher, countdown, Windows power commands, `power_after_task` tool |
+| `client.js` | Web UI half: the composer-dock control and the `shell.overlay` countdown ribbon |
+| `cordis.patch.yml` | The plugin row, disabled by default, with its `config` |
+| `locale/en.json`, `locale/fa.json` | Plugin Manager title and description (`meta.title`, `meta.description`) |
+| `icon.svg` | Plugin Manager artwork |
+
+No build step, no dependencies.
+
+## Troubleshooting
+
+| Symptom | Fix |
+| --- | --- |
+| No dock entry | The row is disabled — enable it in Settings → Plugins; the entry appears within a couple of seconds |
+| Arm answers `answered 403` | Open `http://127.0.0.1:<port>/power-task/debug` and read `lastPost`: it shows the `host`, `secFetchSite`, `origin` and `accepted` of your click. A non-loopback `host` means the page is being served through a proxy or a foreign hostname |
+| Ribbon does not appear after upgrading the plugin | Refresh the page once so the browser loads the new client bundle |
+| Ribbon keeps counting after the task should be protected | That is the design: it counts until the command runs, you Cancel it, or new activity pauses it back to waiting |
+| `… failed` in the ribbon | The Host could not run the command — check power settings, hibernation/fast-startup, or shutdown privileges; Cancel clears the state |
+| Nothing happens when the task ends | The session is still running (a goal continuation, a subagent, or a queued message keeps it `running`) |
+| Control missing on the Desktop app | Expected: that composition has no web server |
+
+## Publish to npm
+
+Publishing needs an npm credential, and `.env` — gitignored and excluded from the tarball — is where it lives on your machine:
+
+```
+NPM_TOKEN=<your npm access token>
+```
+
+Create it at npmjs.com → Account settings → Access tokens → **Granular Access Token**, scoped to `dsh-power-after-task` only, type **Automation**, no read access to private packages, short expiry (`.env.example` documents the format).
+
+```sh
+npm run publish:local
+```
+
+`scripts/publish.mjs` reads `NPM_TOKEN` from `.env` (or the environment), writes it into a throwaway `.npmrc` under your temp directory with owner-only access, runs `npm publish --access public` — which still runs `prepublishOnly` → `npm run check` first — and deletes that file when the publish returns. npm 10 ignores `${VAR}` interpolation inside `--userconfig`, so the value has to be written literally there. The token appears in no command line, no npm output, no commit, and no tarball; nothing publishes without it.
+
+## License
+
+MIT — see `LICENSE`.

package/client.js

@@ -0,0 +1,425 @@
+/**
+ * Client half of `dsh-power-after-task`.
+ *
+ * Two seats:
+ * - `conversation.composer.dock` — the control itself: one power icon that
+ *   expands inline into an Action drop-down, a Grace drop-down, and Arm. While
+ *   armed it prints nothing: a smaller lit icon plus Cancel is the whole message.
+ * - `shell.overlay` — the frame-wide ribbon that counts down once the task has
+ *   finished: minutes, seconds, milliseconds, and one tiny line naming the
+ *   action it is counting down to.
+ *
+ * State lives entirely in the Host half. Both seats read and write it through
+ * this package's own routes — requested document-relative, as the shipped HMR
+ * client requests its event stream. A failed fetch means the Host half is not
+ * running (the row is disabled), so both seats disappear instead of showing
+ * stale state.
+ *
+ * Every colour comes from a `--dsw-alias-*` theme token, so light and dark
+ * settings carry the plugin; semi-transparent surfaces mix a token with
+ * `transparent` rather than inventing a colour.
+ *
+ * @module dsh-power-after-task/client
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-power-after-task',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+
+    /** Document-relative app routes (the shell may serve the page under a path). */
+    const STATE_ROUTE = 'power-task/state'
+    const ARMS_ROUTE = 'power-task/state'
+    const DEFAULTS_ROUTE = 'power-task/defaults'
+    const ARM_ROUTE = 'power-task/arm'
+    const CANCEL_ROUTE = 'power-task/cancel'
+    /** Grace choices: seconds, plus the label shown in the drop-down. */
+    const GRACE_CHOICES = [
+      [15, '15s'],
+      [30, '30s'],
+      [60, '1m'],
+      [120, '2m'],
+      [300, '5m'],
+    ]
+
+    /**
+     * Call this package's Host routes, through the shell transport when there is one.
+     * @param path - document-relative route.
+     * @param body - request body, omitted for a GET.
+     * @returns the parsed JSON answer.
+     */
+    function request(path, body) {
+      const transport = globalThis.__DSH_TRANSPORT__
+      const fetchImpl = transport?.fetch ?? globalThis.fetch
+      return Promise.resolve(fetchImpl(path, body === undefined
+        ? { method: 'GET' }
+        : { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) }))
+        .then((res) => {
+          if (!res.ok) throw new Error(`${path} answered ${res.status}`)
+          return res.json()
+        })
+    }
+
+    /**
+     * Format a countdown as `m:ss.mmm`.
+     * @param ms - milliseconds remaining.
+     * @returns the clock text.
+     */
+    function clock(ms) {
+      const total = Math.max(0, ms)
+      const minutes = Math.floor(total / 60000)
+      const seconds = Math.floor((total % 60000) / 1000)
+      const millis = Math.floor(total % 1000)
+      return `${minutes}:${String(seconds).padStart(2, '0')}.${String(millis).padStart(3, '0')}`
+    }
+
+    /** The power glyph, drawn in the current text colour. */
+    function PowerIcon(size) {
+      return h('svg', {
+        viewBox: '0 0 24 24', width: size, height: size, 'aria-hidden': true,
+        fill: 'none', stroke: 'currentColor', strokeWidth: 2, strokeLinecap: 'round',
+        style: { display: 'block' },
+      },
+        h('path', { d: 'M12 3v8' }),
+        h('path', { d: 'M18.4 6.6a9 9 0 1 1-12.77.04' }))
+    }
+
+    /** Shared compact chrome for the two seats, built only from theme tokens. */
+    const chrome = {
+      appearance: 'none',
+      font: 'inherit',
+      fontSize: 11,
+      lineHeight: 1.4,
+      color: 'var(--dsw-alias-label-primary)',
+      background: 'var(--dsw-alias-bg-layer-1)',
+      border: '1px solid var(--dsw-alias-border-l1)',
+      borderRadius: 6,
+      padding: '2px 6px',
+    }
+
+    /**
+     * The composer-dock control.
+     * @param props - slot props (`sessionId`) plus the registration's `inject`.
+     * @returns the entry element.
+     */
+    function PowerAfterTask(props) {
+      const { sessionId, t, request: call } = props
+      const [open, setOpen] = React.useState(false)
+      const [available, setAvailable] = React.useState(true)
+      const [actions, setActions] = React.useState(['sleep', 'shutdown', 'restart'])
+      const [action, setAction] = React.useState('shutdown')
+      const [grace, setGrace] = React.useState(45)
+      const [state, setState] = React.useState({ state: 'off', running: false })
+      const [remaining, setRemaining] = React.useState(0)
+      const [failure, setFailure] = React.useState('')
+      const primed = React.useRef(false)
+
+      // Defaults on the first success; the loop doubles as the availability probe,
+      // so disabling the row removes this entry within a couple of seconds.
+      React.useEffect(() => {
+        let alive = true
+        const probe = () => call(DEFAULTS_ROUTE).then((info) => {
+          if (!alive) return
+          if (!info?.actions) { setAvailable(false); primed.current = false; return }
+          setAvailable(true)
+          if (primed.current) return
+          primed.current = true
+          setActions(Array.isArray(info.actions) ? info.actions : ['sleep', 'shutdown', 'restart'])
+          if (info.defaultAction) setAction(info.defaultAction)
+          if (Number.isFinite(info.graceSeconds)) setGrace(info.graceSeconds)
+        }, () => {
+          if (!alive) return
+          setAvailable(false)
+          primed.current = false
+        })
+        probe()
+        const timer = setInterval(probe, 2000)
+        return () => { alive = false; clearInterval(timer) }
+      }, [call])
+
+      React.useEffect(() => {
+        let alive = true
+        call(`${STATE_ROUTE}?session=${encodeURIComponent(sessionId)}`).then((info) => {
+          if (alive && info) setState(info)
+        }, () => {})
+        return () => { alive = false }
+      }, [call, sessionId])
+
+      // One tick per second while an arm exists: it refreshes Host state and the clock.
+      React.useEffect(() => {
+        if (state.state === 'off') {
+          setRemaining(0)
+          return undefined
+        }
+        const tick = () => {
+          setRemaining(state.endsAt ? state.endsAt - Date.now() : 0)
+          call(`${STATE_ROUTE}?session=${encodeURIComponent(sessionId)}`).then((info) => {
+            if (info) setState(info)
+          }, () => {})
+        }
+        tick()
+        const timer = setInterval(tick, 1000)
+        return () => clearInterval(timer)
+      }, [call, sessionId, state.state, state.endsAt, state.action])
+
+      /**
+       * Send one operation and adopt the state it reports.
+       * @param path - route to post to.
+       * @param body - request body.
+       */
+      const send = (path, body) => {
+        setFailure('')
+        call(path, body).then((info) => {
+          if (info) setState(info)
+        }, (error) => setFailure(error instanceof Error ? error.message : String(error)))
+      }
+
+      const label = (id) => t(`action.${id}`)
+      const armed = state.state !== 'off'
+      const counting = state.state === 'counting'
+      const failed = state.state === 'failed'
+      const accent = failed || counting
+        ? 'var(--dsw-alias-state-warn-primary)'
+        : 'var(--dsw-alias-brand-primary)'
+      const choices = GRACE_CHOICES.some(([seconds]) => seconds === grace)
+        ? GRACE_CHOICES
+        : [[grace, `${grace}s`], ...GRACE_CHOICES]
+      // Nothing is printed while armed: a smaller lit icon plus Cancel carries the
+      // whole message. Action and remaining time stay reachable as a hover title.
+      const hover = armed
+        ? `${label(state.action)} · ${failed ? (state.detail ?? t('failed')) : counting ? clock(remaining) : t('waiting')}`
+        : t('tooltip')
+      const shown = failure || (failed ? `${label(state.action)} · ${state.detail ?? t('failed')}` : '')
+
+      if (!sessionId || !available) return null
+
+      return h('div', {
+        style: { display: 'flex', alignItems: 'center', gap: 5, flexWrap: 'wrap' },
+      },
+        h('button', {
+          type: 'button',
+          'aria-expanded': open,
+          'aria-label': armed ? `${t('title')} · ${label(state.action)}` : t('title'),
+          title: hover,
+          style: {
+            ...chrome,
+            display: 'flex',
+            alignItems: 'center',
+            padding: armed ? '2px 5px' : '3px 6px',
+            cursor: 'pointer',
+            color: armed ? accent : 'var(--dsw-alias-label-secondary)',
+            borderColor: armed ? accent : 'var(--dsw-alias-border-l1)',
+          },
+          onClick: () => { setFailure(''); setOpen((value) => !value) },
+        }, PowerIcon(armed ? 11 : 14)),
+        armed ? h('button', {
+          type: 'button',
+          title: hover,
+          style: { ...chrome, color: accent, cursor: 'pointer' },
+          onClick: () => send(CANCEL_ROUTE, { sessionId }),
+        }, t('cancel')) : null,
+        open ? h('select', {
+          title: t('actionLabel'),
+          disabled: armed,
+          value: armed ? state.action : action,
+          onChange: (event) => setAction(event.target.value),
+          style: { ...chrome, cursor: armed ? 'default' : 'pointer' },
+        }, actions.map((id) => h('option', { key: id, value: id }, label(id)))) : null,
+        open ? h('select', {
+          title: t('graceLabel'),
+          disabled: armed,
+          value: String(armed ? state.graceSeconds : grace),
+          onChange: (event) => setGrace(Number(event.target.value)),
+          style: { ...chrome, cursor: armed ? 'default' : 'pointer' },
+        }, choices.map(([seconds, text]) => h('option', { key: seconds, value: String(seconds) }, `${t('graceLabel')} ${text}`))) : null,
+        open && !armed ? h('button', {
+          type: 'button',
+          style: { ...chrome, color: accent, borderColor: 'var(--dsw-alias-border-l2)', cursor: 'pointer' },
+          onClick: () => send(ARM_ROUTE, { sessionId, action, graceSeconds: grace }),
+        }, t('arm')) : null,
+        shown ? h('span', { style: { color: 'var(--dsw-alias-state-error-primary)' } }, shown) : null)
+    }
+
+    /**
+     * The frame-wide countdown ribbon, shown only while a countdown is running
+     * (or while a power action reported a failure). It never blocks the page:
+     * only its Cancel button takes pointer events.
+     * @param props - the registration's `inject`.
+     * @returns the overlay element, or `null`.
+     */
+    function CountdownRibbon(props) {
+      const { t, request: call } = props
+      const [arms, setArms] = React.useState([])
+      const [live, setLive] = React.useState(true)
+      const [now, setNow] = React.useState(() => Date.now())
+      const counting = arms.find((arm) => arm.state === 'counting') ?? null
+      const failedArm = arms.find((arm) => arm.state === 'failed') ?? null
+      const ribbon = counting ?? failedArm
+
+      React.useEffect(() => {
+        let alive = true
+        const probe = () => call(ARMS_ROUTE).then((info) => {
+          if (!alive) return
+          setLive(true)
+          setArms(Array.isArray(info?.arms) ? info.arms : [])
+        }, () => {
+          if (!alive) return
+          setLive(false)
+          setArms([])
+        })
+        probe()
+        const timer = setInterval(probe, 1000)
+        return () => { alive = false; clearInterval(timer) }
+      }, [call])
+
+      // Animation frames give the millisecond digits a smooth update.
+      React.useEffect(() => {
+        if (!counting) return undefined
+        let frame = requestAnimationFrame(function loop() {
+          setNow(Date.now())
+          frame = requestAnimationFrame(loop)
+        })
+        return () => cancelAnimationFrame(frame)
+      }, [counting?.state, counting?.endsAt])
+
+      /**
+       * Cancel the countdown this ribbon is showing.
+       */
+      const cancel = () => {
+        if (!ribbon?.sessionId) return
+        call(CANCEL_ROUTE, { sessionId: ribbon.sessionId }).then(() => setNow(Date.now()), () => {})
+      }
+
+      if (!live || !ribbon) return null
+
+      const remaining = ribbon.endsAt ? Math.max(0, ribbon.endsAt - now) : 0
+      const accent = failedArm
+        ? 'var(--dsw-alias-state-error-primary)'
+        : 'var(--dsw-alias-state-warn-primary)'
+      const caption = failedArm
+        ? `${t(`action.${failedArm.action}`)} · ${failedArm.detail ?? t('failed')}`
+        : t(`until.${counting.action}`)
+
+      return h('div', {
+        'aria-live': 'polite',
+        style: {
+          position: 'fixed',
+          inset: 0,
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          pointerEvents: 'none',
+          zIndex: 40,
+          font: 'inherit',
+        },
+      },
+        h('div', {
+          style: {
+            width: '100%',
+            display: 'flex',
+            flexDirection: 'column',
+            alignItems: 'center',
+            gap: 6,
+            padding: '30px 16px',
+            background: 'color-mix(in srgb, var(--dsw-alias-bg-overlay) 68%, transparent)',
+            borderTop: '1px solid var(--dsw-alias-border-l2)',
+            borderBottom: '1px solid var(--dsw-alias-border-l2)',
+            backdropFilter: 'blur(8px)',
+            boxShadow: '0 0 40px color-mix(in srgb, var(--dsw-alias-bg-base) 55%, transparent)',
+          },
+        },
+          h('div', {
+            style: {
+              fontSize: 'clamp(54px, 13vw, 150px)',
+              fontWeight: 700,
+              lineHeight: 1,
+              letterSpacing: '-0.02em',
+              color: accent,
+              fontVariantNumeric: 'tabular-nums',
+            },
+          }, clock(remaining)),
+          h('div', {
+            style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', letterSpacing: '0.01em' },
+          }, caption),
+          h('button', {
+            type: 'button',
+            style: { ...chrome, pointerEvents: 'auto', color: 'var(--dsw-alias-state-error-primary)', cursor: 'pointer', marginTop: 4 },
+            onClick: cancel,
+          }, t('cancel')))
+      )
+    }
+
+    return {
+      inject: ['slots', 'locale'],
+      apply(ctx) {
+        const dicts = {
+          en: {
+            title: 'Power after task',
+            tooltip: 'Sleep, shut down, or restart this PC once the current task finishes.',
+            'action.sleep': 'Sleep',
+            'action.shutdown': 'Shut down',
+            'action.restart': 'Restart',
+            'until.sleep': 'Until sleep',
+            'until.shutdown': 'Until shut down',
+            'until.restart': 'Until restart',
+            arm: 'Arm',
+            cancel: 'Cancel',
+            waiting: 'waiting for the task to finish',
+            failed: 'the power action failed',
+            actionLabel: 'Action',
+            graceLabel: 'Grace',
+          },
+          fa: {
+            title: 'خاموش‌شدن پس از تسک',
+            tooltip: 'پس از پایان تسک جاری، این رایانه را به حالت خواب ببرد، خاموش کند یا راه‌اندازی مجدد کند.',
+            'action.sleep': 'خواب',
+            'action.shutdown': 'خاموش',
+            'action.restart': 'راه‌اندازی مجدد',
+            'until.sleep': 'تا خواب',
+            'until.shutdown': 'تا خاموشی',
+            'until.restart': 'تا راه‌اندازی مجدد',
+            arm: 'آماده‌سازی',
+            cancel: 'لغو',
+            waiting: 'در انتظار پایان تسک',
+            failed: 'کنش برقی انجام نشد',
+            actionLabel: 'کنش',
+            graceLabel: 'مهلت',
+          },
+        }
+        return ctx.effect(() => {
+          const disposers = [
+            ctx.locale.register('power-after-task', 'en', dicts.en),
+            ctx.locale.register('power-after-task', 'fa', dicts.fa),
+          ]
+          const translate = ctx.locale.bind('power-after-task')
+          /**
+           * Translate one key, falling back to the English dictionary when the
+           * registry has no entry for it, so the control never prints a raw key.
+           * @param key - dictionary key.
+           * @returns the text to show.
+           */
+          const t = (key) => {
+            const value = translate(key)
+            return typeof value === 'string' && value !== key ? value : (dicts.en[key] ?? key)
+          }
+          const injected = () => ({ t, request })
+          disposers.push(ctx.slots.inject('conversation.composer.dock', () => ctx.slots.register({
+            name: 'conversation.composer.dock',
+            id: 'power-after-task',
+            order: 2,
+            label: () => t('title'),
+            inject: injected,
+          }, PowerAfterTask)))
+          disposers.push(ctx.slots.inject('shell.overlay', () => ctx.slots.register({
+            name: 'shell.overlay',
+            id: 'power-after-task-countdown',
+            order: 20,
+            label: () => t('title'),
+            inject: injected,
+          }, CountdownRibbon)))
+          return () => { for (const dispose of disposers) dispose() }
+        }, 'power-after-task: locale, dock control, and countdown ribbon')
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,12 @@
+- insert:
+    - id: power-after-task
+      name: 'dsh-power-after-task'
+      # Installed but off: nothing runs, and no dock entry appears, until the
+      # row is enabled in Settings → Plugins → “Power after task”.
+      disabled: true
+      config:
+        # One of 'sleep', 'shutdown', 'restart' — the action the control preselects.
+        defaultAction: shutdown
+        # Grace period, in seconds, between the task finishing and the power action running.
+        # The countdown can be cancelled while it runs.
+        graceSeconds: 45

package/icon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Power after task">
+  <circle cx="32" cy="32" r="28" fill="#1f2937"/>
+  <circle cx="32" cy="32" r="28" fill="none" stroke="#247bbf" stroke-width="2"/>
+  <path d="M32 16v16" fill="none" stroke="#7fc6ff" stroke-width="5" stroke-linecap="round"/>
+  <path d="M44.97 23.03a18.4 18.4 0 1 1-25.94 0" fill="none" stroke="#7fc6ff" stroke-width="5" stroke-linecap="round"/>
+  <path d="M46 44a7 7 0 0 1-8.6-8.6A7 7 0 0 0 46 44z" fill="#f0b429"/>
+</svg>

package/index.js

@@ -0,0 +1,472 @@
+/**
+ * Host half of `dsh-power-after-task`.
+ *
+ * One operation, two callers (see the plugin-development practice notes):
+ * `arm`, `cancel`, `status`, and `execute` are implemented once here and reach
+ * the page through a plugin-owned HTTP route, while the `power_after_task`
+ * tool exposes the same four operations to the agent.
+ *
+ * A request is armed for one session. The countdown starts when that session's
+ * Agent stops running; if the Agent starts running again the countdown returns
+ * to waiting, so a goal driver or a follow-up message never powers the machine
+ * out from under the work.
+ *
+ * Requires the Web composition (`ctx.webServer`) and runs on Windows only.
+ *
+ * @module dsh-power-after-task
+ */
+import { spawn } from 'node:child_process'
+
+/** Power targets this build can drive. */
+const POWER_ACTIONS = ['sleep', 'shutdown', 'restart']
+/** Used when the row's `config` supplies no usable grace period. */
+const FALLBACK_GRACE_SECONDS = 45
+/** Upper bound on a countdown, so a bad argument cannot schedule a year of waiting. */
+const MAX_GRACE_SECONDS = 3600
+/** Body ceiling for the plugin route. */
+const MAX_BODY_BYTES = 8 * 1024
+/** One prefix route owns every endpoint below. */
+const ROUTE = '/power-task'
+
+/**
+ * PowerShell that suspends the machine through `kernel32!ApplicationSuspend`.
+ * `rundll32 powrprof.dll,SetSuspendState` hibernates whenever hibernation is
+ * enabled, so it only serves as the fallback below.
+ */
+const SLEEP_SCRIPT = [
+  "Add-Type -TypeDefinition 'using System.Runtime.InteropServices; public static class DshPower { [DllImport(\"kernel32.dll\", SetLastError = true)] public static extern bool ApplicationSuspend(); }' -Name DshPower -Namespace Dsh",
+  'if ([Dsh.DshPower]::ApplicationSuspend()) { exit 0 } else { exit 1 }',
+].join('\n')
+
+/**
+ * Run one program to completion.
+ * @param command - executable to spawn.
+ * @param args - its argument vector.
+ * @returns a promise that resolves on exit code 0.
+ */
+function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: 'ignore', windowsHide: true })
+    child.once('error', (error) => reject(new Error(`${command}: ${error.message}`)))
+    child.once('exit', (code, signal) => {
+      if (code === 0) resolve()
+      else reject(new Error(`${command} ${args.join(' ')} exited (${code ?? signal ?? 'unknown'})`))
+    })
+  })
+}
+
+/**
+ * Ask Windows to carry out one power action.
+ * @param action - `sleep`, `shutdown`, or `restart`.
+ * @returns a promise that rejects with the reason the machine stayed up.
+ */
+async function runPowerAction(action) {
+  if (process.platform !== 'win32') {
+    throw new Error(`power-after-task drives Windows; this Host runs on ${process.platform}`)
+  }
+  if (!POWER_ACTIONS.includes(action)) throw new Error(`unknown power action '${action}'`)
+  if (action === 'shutdown') return runCommand('shutdown.exe', ['/s', '/t', '0', '/c', 'DSH power-after-task'])
+  if (action === 'restart') return runCommand('shutdown.exe', ['/r', '/t', '0', '/c', 'DSH power-after-task'])
+
+  const failures = []
+  try {
+    return await runCommand('powershell.exe', [
+      '-NoProfile',
+      '-NonInteractive',
+      '-ExecutionPolicy',
+      'Bypass',
+      '-Command',
+      SLEEP_SCRIPT,
+    ])
+  } catch (error) {
+    failures.push(error instanceof Error ? error.message : String(error))
+  }
+  try {
+    return await runCommand('rundll32.exe', ['powrprof.dll,SetSuspendState', '0,0,0'])
+  } catch (error) {
+    failures.push(error instanceof Error ? error.message : String(error))
+  }
+  throw new Error(`sleep failed: ${failures.join(' ; ')}`)
+}
+
+/**
+ * Read a request body as JSON.
+ * @param req - the incoming request.
+ * @returns the parsed object, or `{}` for an empty body.
+ */
+async function readJsonBody(req) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of req) {
+    size += chunk.length
+    if (size > MAX_BODY_BYTES) throw new Error('request body too large')
+    chunks.push(chunk)
+  }
+  if (!chunks.length) return {}
+  const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('body must be a JSON object')
+  return parsed
+}
+
+/** Services this Host half needs from the composition. */
+export const inject = ['webServer', 'timer', 'tools', 'sessionController']
+
+export function apply(ctx, config) {
+  const defaultAction = POWER_ACTIONS.includes(config?.defaultAction) ? config.defaultAction : 'shutdown'
+  const configuredGrace = Number(config?.graceSeconds)
+  const defaultGrace = Number.isFinite(configuredGrace) && configuredGrace >= 0
+    ? Math.min(configuredGrace, MAX_GRACE_SECONDS)
+    : FALLBACK_GRACE_SECONDS
+  /** This server's own origin, read lazily so activation order cannot break it. */
+  const serverOrigin = () => {
+    try {
+      return new URL(ctx.webServer.getOrigin())
+    } catch {
+      return undefined
+    }
+  }
+
+  /** Sessions whose Agent is currently running. */
+  const running = new Set()
+  /** One entry per armed session: `{ action, graceSeconds, endsAt, cancelTimer }`. */
+  const pending = new Map()
+
+  const log = (message) => ctx.logger?.info?.(`power-after-task: ${message}`)
+
+  /** Diagnostic from the last running-state read, surfaced by `/power-task/debug`. */
+  let seedFailure = ''
+  /** Headers the last mutating request carried, so a rejected Arm is diagnosable. */
+  let lastPost = null
+  let postAttempts = 0
+  /** Headers the last read request carried: the page polls here every couple of seconds. */
+  let lastGet = null
+  let getAttempts = 0
+
+  /**
+   * Ask the Session domain which Agents are running, so an arm made before this
+   * plugin saw a session's first status event is still correct.
+   * @param sessionId - one session to refresh, omitted to refresh every row.
+   */
+  async function refreshRunning(sessionId) {
+    try {
+      const value = await ctx.sessionController.list({}, new AbortController().signal)
+      for (const item of value?.items ?? []) {
+        if (sessionId && item.sessionId !== sessionId) continue
+        if (item.running) running.add(item.sessionId)
+        else running.delete(item.sessionId)
+      }
+      seedFailure = ''
+    } catch (error) {
+      seedFailure = error instanceof Error ? error.message : String(error)
+      // The status-event feed remains authoritative when the read is unavailable.
+    }
+  }
+
+  /**
+   * Stop a running countdown without forgetting the arm.
+   * @param entry - the pending entry to pause.
+   */
+  function pauseCountdown(entry) {
+    entry.cancelTimer?.()
+    entry.cancelTimer = undefined
+    entry.endsAt = undefined
+  }
+
+  /**
+   * Carry out the armed action. The arm stays visible until the command runs
+   * successfully or the user cancels it: a command that fails leaves the entry
+   * in the `failed` state instead of silently returning to normal.
+   * @param sessionId - the session whose arm fired.
+   */
+  function fire(sessionId) {
+    const entry = pending.get(sessionId)
+    if (!entry) return
+    pauseCountdown(entry)
+    log(`${entry.action} scheduled for session ${sessionId}`)
+    runPowerAction(entry.action).then(
+      () => {
+        pending.delete(sessionId)
+        log(`${entry.action} executed`)
+      },
+      (error) => {
+        entry.failed = error instanceof Error ? error.message : String(error)
+        log(`${entry.action} failed: ${entry.failed}`)
+      },
+    )
+  }
+
+  /**
+   * Begin (or restart) the grace countdown for one armed entry.
+   * @param sessionId - the session to count down for.
+   * @param entry - its pending entry.
+   */
+  function startCountdown(sessionId, entry) {
+    pauseCountdown(entry)
+    entry.endsAt = Date.now() + entry.graceSeconds * 1000
+    entry.cancelTimer = ctx.timer.timeout(() => fire(sessionId), entry.graceSeconds * 1000)
+  }
+
+  /**
+   * Arm one session for a power action.
+   * @param sessionId - the session to watch.
+   * @param action - `sleep`, `shutdown`, or `restart`.
+   * @param graceSeconds - countdown length after the task finishes.
+   * @returns the state the caller can display.
+   */
+  async function arm(sessionId, action = defaultAction, graceSeconds = defaultGrace) {
+    if (!POWER_ACTIONS.includes(action)) throw new Error(`unknown power action '${action}'`)
+    const grace = Math.min(Math.max(Number(graceSeconds) || 0, 0), MAX_GRACE_SECONDS)
+    const entry = { action, graceSeconds: grace, endsAt: undefined, cancelTimer: undefined }
+    pending.set(sessionId, entry)
+    // A session this plugin never saw start can still be mid-turn, so check the
+    // Session domain before concluding that its task is already finished.
+    if (!running.has(sessionId)) await refreshRunning(sessionId)
+    // An idle session is already "finished", so the countdown begins at once;
+    // a message sent inside the grace window puts it back to waiting.
+    if (!running.has(sessionId)) startCountdown(sessionId, entry)
+    return stateOf(sessionId)
+  }
+
+  /**
+   * Forget one arm, cancelling any countdown already running.
+   * @param sessionId - the session to clear.
+   */
+  function cancel(sessionId) {
+    const entry = pending.get(sessionId)
+    if (entry) pauseCountdown(entry)
+    pending.delete(sessionId)
+    return stateOf(sessionId)
+  }
+
+  /**
+   * Current state of one session's arm.
+   * @param sessionId - the session to report.
+   * @returns `{ state, running, ... }`.
+   */
+  function stateOf(sessionId) {
+    const entry = pending.get(sessionId)
+    if (!entry) return { state: 'off', running: running.has(sessionId) }
+    return {
+      state: entry.failed ? 'failed' : entry.endsAt ? 'counting' : 'armed',
+      action: entry.action,
+      graceSeconds: entry.graceSeconds,
+      endsAt: entry.endsAt ?? null,
+      detail: entry.failed,
+      running: running.has(sessionId),
+    }
+  }
+
+  /**
+   * Whether a host value names this machine. A rebinding attack reaches the
+   * port under a foreign name, so the Host header is what separates the page
+   * from an outside web page.
+   * @param value - a `Host` or URL hostname, with or without a port.
+   * @returns whether it is a loopback name.
+   */
+  function isLoopbackHost(value) {
+    const host = String(value ?? '').toLowerCase()
+    if (!host) return false
+    const closing = host.lastIndexOf(']')
+    const bare = closing > 0 ? host.slice(1, closing) : host.split(':')[0]
+    return bare === 'localhost' || bare === '127.0.0.1' || bare === '::1'
+  }
+
+  /**
+   * Refuse a read request that proves it came from elsewhere.
+   * @param req - the incoming request.
+   * @returns whether the request may be served.
+   */
+  function isSameOrigin(req) {
+    const site = req.headers['sec-fetch-site']
+    if (typeof site === 'string') return site === 'same-origin' || site === 'none'
+    const origin = req.headers['origin']
+    if (typeof origin !== 'string') return true
+    try {
+      return isLoopbackHost(new URL(origin).hostname)
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Whether a mutating request is trusted. A request is refused only when it
+   * proves it is not the page: addressed to a non-loopback host (DNS
+   * rebinding or a foreign vhost), reported by the browser as cross-site, or
+   * sent with a non-loopback `Origin`. A request carrying none of that
+   * evidence passes: it is the Harness page through its own transport, or a
+   * local process — which could run `shutdown.exe` directly anyway.
+   * @param req - the incoming request.
+   * @returns whether Arm or Cancel may run.
+   */
+  function fromPage(req) {
+    const host = req.headers.host
+    if (typeof host === 'string' && !isLoopbackHost(host)) return false
+    const site = req.headers['sec-fetch-site']
+    if (typeof site === 'string' && site !== 'same-origin' && site !== 'none') return false
+    const origin = req.headers['origin']
+    if (typeof origin === 'string') {
+      try {
+        if (!isLoopbackHost(new URL(origin).hostname)) return false
+      } catch {
+        return false
+      }
+    }
+    return true
+  }
+
+  /**
+   * Answer one plugin-route request.
+   * @param req - the incoming request.
+   * @param res - the response to own.
+   */
+  async function handle(req, res) {
+    const reply = (status, body) => {
+      res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' })
+      res.end(JSON.stringify(body))
+    }
+    if (!isSameOrigin(req)) return reply(403, { error: 'this endpoint is only reachable from the Harness page' })
+
+    const path = (req.url ?? '').split('?')[0]
+    const sub = path.slice(ROUTE.length).replace(/^\//, '')
+    try {
+      if (sub === 'debug') return reply(200, {
+        marker: 'guard-v6',
+        platform: process.platform,
+        running: [...running],
+        pending: [...pending.keys()],
+        seedFailure,
+        guard: 'refuse non-loopback host, cross-site, or non-loopback origin',
+        serverOrigin: serverOrigin() ?? null,
+        postAttempts,
+        lastPost,
+        getAttempts,
+        lastGet,
+      })
+      if (sub === 'defaults') return reply(200, { actions: POWER_ACTIONS, defaultAction, graceSeconds: defaultGrace })
+      if (req.method === 'GET' && (sub === 'defaults' || sub === 'state')) {
+        getAttempts += 1
+        lastGet = {
+          at: new Date().toISOString(),
+          path,
+          host: req.headers.host ?? null,
+          secFetchSite: req.headers['sec-fetch-site'] ?? null,
+          origin: req.headers['origin'] ?? null,
+          cookie: Boolean(req.headers.cookie),
+        }
+      }
+      if (req.method === 'GET' && sub === 'state') {
+        const query = new URLSearchParams((req.url ?? '').split('?')[1] ?? '').get('session')
+        return reply(200, query ? stateOf(query) : {
+          arms: [...pending.keys()].map((id) => ({ sessionId: id, ...stateOf(id) })),
+        })
+      }
+      if (req.method !== 'POST') return reply(405, { error: `unsupported method ${req.method ?? 'unknown'}` })
+      postAttempts += 1
+      const accepted = fromPage(req)
+      lastPost = {
+        at: new Date().toISOString(),
+        path,
+        host: req.headers.host ?? null,
+        secFetchSite: req.headers['sec-fetch-site'] ?? null,
+        origin: req.headers['origin'] ?? null,
+        contentType: req.headers['content-type'] ?? null,
+        accepted,
+      }
+      // Arming and cancelling are mutating: they refuse a request that proves it
+      // is not this page.
+      if (!accepted) {
+        return reply(403, { error: 'this control only accepts requests from the Harness page', hint: 'see /power-task/debug' })
+      }
+
+      const body = await readJsonBody(req)
+      if (sub === 'arm') {
+        const sessionId = String(body.sessionId ?? '')
+        if (!sessionId) return reply(400, { error: 'sessionId is required' })
+        return reply(200, await arm(sessionId, body.action ?? defaultAction, body.graceSeconds ?? defaultGrace))
+      }
+      if (sub === 'cancel') {
+        const sessionId = String(body.sessionId ?? '')
+        if (!sessionId) return reply(400, { error: 'sessionId is required' })
+        return reply(200, cancel(sessionId))
+      }
+      return reply(404, { error: `unknown power-task endpoint '${sub}'` })
+    } catch (error) {
+      return reply(400, { error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  return ctx.effect(() => {
+    const disposer = ctx.webServer.register({ kind: 'prefix', path: ROUTE, handler: handle })
+    // A session already running when this plugin activates never emits a status
+    // event this plugin observes, so seed the running set once.
+    void refreshRunning()
+
+    ctx.on('api-session/status', (sessionId, isRunning) => {
+      const entry = pending.get(sessionId)
+      if (isRunning) {
+        running.add(sessionId)
+        if (entry?.endsAt) pauseCountdown(entry)
+      } else {
+        running.delete(sessionId)
+        if (entry && !entry.endsAt && !entry.failed) startCountdown(sessionId, entry)
+      }
+    })
+
+    // A session leaving the live registry has no further work to protect.
+    ctx.on('api-session/removed', (sessionId) => {
+      running.delete(sessionId)
+      const entry = pending.get(sessionId)
+      if (entry && !entry.endsAt && !entry.failed) startCountdown(sessionId, entry)
+    })
+
+    ctx.tools.register({
+      name: 'power_after_task',
+      description:
+        'Arm, cancel, or inspect a Windows power action that runs when a session’s task finishes, '
+        + 'or run one immediately. Arming starts a cancellable countdown after the Agent stops running.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['status', 'arm', 'cancel', 'execute'], description: 'Which operation to run.' },
+          session: { type: 'string', description: 'Session id to arm or cancel; defaults to the calling session.' },
+          power: { type: 'string', enum: POWER_ACTIONS, description: `Power target; defaults to '${defaultAction}'.` },
+          grace_seconds: { type: 'number', description: `Countdown seconds after the task finishes; defaults to ${defaultGrace}.` },
+        },
+        required: ['action'],
+        additionalProperties: false,
+      },
+      output: {
+        schema: { type: 'object', properties: { state: { type: 'string' }, detail: { type: 'string' } } },
+        render: (args, value) => [{ type: 'text', text: JSON.stringify(value ?? {}, null, 2) }],
+      },
+      execute: async (args, exec) => {
+        const sessionId = args.session ?? exec?.agent?.id
+        try {
+          if (args.action === 'status') return sessionId ? stateOf(sessionId) : { state: 'off', running: false }
+          if (args.action === 'arm') {
+            if (!sessionId) throw new Error('no session to arm')
+            return await arm(sessionId, args.power ?? defaultAction, args.grace_seconds ?? defaultGrace)
+          }
+          if (args.action === 'cancel') {
+            if (!sessionId) throw new Error('no session to cancel')
+            return cancel(sessionId)
+          }
+          if (args.action === 'execute') {
+            await runPowerAction(args.power ?? defaultAction)
+            return { state: 'executed', detail: String(args.power ?? defaultAction) }
+          }
+          throw new Error(`unknown action '${args.action}'`)
+        } catch (error) {
+          return { state: 'error', detail: error instanceof Error ? error.message : String(error) }
+        }
+      },
+    })
+
+    return () => {
+      disposer()
+      for (const entry of pending.values()) pauseCountdown(entry)
+      pending.clear()
+      running.clear()
+    }
+  }, 'power-after-task: route, events, and tool')
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Power after task",
+    "description": "Sleep, shut down, or restart this Windows PC after the current task finishes, with a cancellable grace countdown in the composer dock and a full-width countdown ribbon. Off by default: enable this row here."
+  }
+}

package/locale/fa.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "خاموش‌شدن پس از تسک",
+    "description": "این رایانه ویندوزی را پس از پایان تسک جاری به حالت خواب ببرد، خاموش کند یا راه‌اندازی مجدد کند؛ با شمارش معکوس قابل لغو در نوار زیر پیام‌نویس و روبان شمارش معکوس روی صفحه. به‌طور پیش‌فرض خاموش است: این ردیف را اینجا فعال کنید."
+  }
+}

package/package.json

@@ -1,6 +1,71 @@
 {
   "name": "dsh-power-after-task",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "DeepSeek Harness plugin: sleep, shut down, or restart this Windows PC after the current agent task finishes, with a cancellable grace countdown in the composer dock.",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "cordis",
+    "plugin",
+    "bundle",
+    "windows",
+    "power",
+    "sleep",
+    "shutdown",
+    "restart"
+  ],
+  "license": "MIT",
+  "author": "Mori",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/white-sparrow/dsh-power-after-task.git"
+  },
+  "homepage": "https://github.com/white-sparrow/dsh-power-after-task#readme",
+  "bugs": {
+    "url": "https://github.com/white-sparrow/dsh-power-after-task/issues"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "check": "node --check index.js && node --check client.js",
+    "prepublishOnly": "npm run check",
+    "prepack": "npm run check",
+    "stage": "node scripts/npm-auth.mjs stage publish",
+    "stage:list": "node scripts/npm-auth.mjs stage list",
+    "stage:view": "node scripts/npm-auth.mjs stage view",
+    "stage:approve": "node scripts/npm-auth.mjs stage approve",
+    "stage:reject": "node scripts/npm-auth.mjs stage reject",
+    "stage:download": "node scripts/npm-auth.mjs stage download",
+    "publish:local": "node scripts/npm-auth.mjs publish"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dsh": {
+    "bundle": { "patch": "./cordis.patch.yml" },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": ["@deepseek-ai/dsh-client-ui-conversation"]
+    }
+  }
+}