@integrity-labs/agt-cli 0.15.0 → 0.15.1

package/dist/bin/agt.js

@@ -45,7 +45,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-WB3T6XIV.js";
+} from "../chunk-7QE6SJQB.js";
 
 // src/bin/agt.ts
 import { join as join9 } from "path";
@@ -3402,7 +3402,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync4, realpathSync } from "fs";
 import chalk17 from "chalk";
 import ora15 from "ora";
-var cliVersion = true ? "0.15.0" : "dev";
+var cliVersion = true ? "0.15.1" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -3851,7 +3851,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.15.0" : "dev";
+var cliVersion2 = true ? "0.15.1" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", (thisCommand) => {

package/dist/{chunk-WB3T6XIV.js → chunk-7QE6SJQB.js}

@@ -533,6 +533,45 @@ function getIntegration(id) {
   return integrationMap.get(id);
 }
 
+// ../../packages/core/dist/provisioning/hook-env.js
+function augmentedHookPath(currentPath) {
+  const extras = [
+    "/home/linuxbrew/.linuxbrew/bin",
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin"
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  const push = (p) => {
+    if (!p || seen.has(p))
+      return;
+    seen.add(p);
+    parts.push(p);
+  };
+  for (const p of (currentPath ?? "").split(":"))
+    push(p);
+  for (const p of extras)
+    push(p);
+  return parts.join(":");
+}
+function extractCommandNotFound(stderr) {
+  if (!stderr)
+    return null;
+  const SAFE_CMD = /^[A-Za-z][A-Za-z0-9._-]{0,63}$/;
+  for (const line of stderr.split(/\r?\n/)) {
+    const m = line.match(/^(?:bash|sh): (?:line \d+: )?([^:\s]+): command not found$/);
+    if (m?.[1]) {
+      const rawCmd = m[1].trim();
+      const cmd = rawCmd.split("/").pop() ?? rawCmd;
+      if (SAFE_CMD.test(cmd))
+        return cmd;
+    }
+  }
+  return null;
+}
+
 // ../../packages/core/dist/provisioning/frameworks/openclaw/index.js
 import { execFile, spawn } from "child_process";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, unlinkSync as unlinkSync2, chmodSync as chmodSync2, renameSync as renameSync2, symlinkSync } from "fs";
@@ -1924,6 +1963,9 @@ ${entry.content}`
         maxBuffer: 1024 * 1024,
         env: {
           ...process.env,
+          // ENG-4510: prepend canonical brew + system bin dirs so hooks
+          // resolve binaries when the manager runs under a minimal PATH.
+          PATH: augmentedHookPath(process.env.PATH),
           AGENT_CODE_NAME: ctx.codeName,
           AGENT_DIR: agentDir,
           AGENT_PROJECT_DIR: projectDir,
@@ -2683,26 +2725,109 @@ are defined in \`CHARTER.md\`.
 **When in doubt, create a task.** Err on the side of tracking work rather than
 doing it silently. Any work that takes more than ~30 seconds should be a kanban task.
 
+But: **clarify before you commit.** A vague task on the board is worse than
+no task \u2014 it bakes in the wrong scope and forces a rename later. If the
+request is fuzzy, ask one or two sharp questions FIRST and create the task
+once you understand what's actually being asked for.
+
 When you receive a request via any channel (Slack, Telegram, direct chat):
 
 1. **First, check if the request is exempt** \u2014 the following do NOT need a task:
    - One-line answers, yes/no questions, or simple factual lookups (under ~30 seconds)
    - No-action acknowledgments: "thanks", "got it", "acknowledged", "will do", or other confirmations that require no further work
-2. **If not exempt, create a kanban task** with kanban.add \u2014 don't wait to see if it's "big enough"
-3. Reply in the channel thread: "On it \u2014 tracking here: ${kanbanUrl ?? "my kanban board"}" (include the created task title)
-4. Move the task to in_progress with kanban.move
-5. Do the work
-6. Mark done with kanban.done including a result summary
-7. Reply in the channel thread with the result
-
-Everything that isn't exempt gets a task.
+2. **If not exempt, check if the request is clear enough to scope a sharp task title.**
+   Ask yourself: "Could I write a one-line task title right now that another
+   teammate would understand without asking me anything?"
+   - **If yes** \u2192 continue to step 3.
+   - **If no** \u2192 reply with **at most two** clarifying questions in the channel
+     thread. Do NOT create the kanban task yet \u2014 it would be wrong by the
+     time you came back. When you ask, also state the default you'll
+     assume if they don't reply (e.g. "If you don't say, I'll go with the
+     standard VP-eyes-on overview"). Once they reply (or you've waited
+     long enough to act on the default), pick up at step 3.
+3. **Create the kanban task** with kanban.add. Title should be specific
+   enough to be self-explanatory \u2014 "Pull Linear ENG sprint velocity for
+   this fortnight" beats "Linear stats".
+4. Reply in the channel thread: "On it \u2014 tracking here: ${kanbanUrl ?? "my kanban board"}" (include the created task title)
+5. Move the task to in_progress with kanban.move
+6. Do the work
+7. Mark done with kanban.done including a result summary
+8. Reply in the channel thread with the result
+
+Everything that isn't exempt gets a task \u2014 but only after the request is
+clear. Don't bury a clarifying question underneath a "tracking here" reply;
+ask the question alone, no kanban link, and let the user answer before
+anything goes on the board.
 
 When asked about existing work, tasks, or what you've been doing \u2014 call kanban.list
 first to load your recent board state. This gives you context about completed and
 in-progress items so you can answer accurately.
 
 ${memorySection}
-${reportsToSection}${teamSection}${peopleSection}${integrationsSection}${knowledgeSection}## Development Workflow
+${reportsToSection}${teamSection}${peopleSection}${integrationsSection}${knowledgeSection}## Dashboards
+
+You can publish your own dashboards inside the Augmented console. They are
+**first-class platform artifacts** \u2014 KPI tiles, charts, refresh-on-demand \u2014
+and replace any urge to write static HTML and host it elsewhere (GitHub
+Pages, public buckets, screenshots in chat).
+
+**When the user asks for a dashboard, do this \u2014 never anything else:**
+
+1. Plan a small set of widgets (KPI tiles for headlines, area/line for
+   trends, bar for comparisons, donut for proportions).
+2. For each widget write \`{id, kind, title, prompt, schema}\`. The
+   \`prompt\` is what future-you reads on every refresh; the \`schema\` is
+   the JSON Schema your output must match.
+3. Call **\`dashboards.upsert\`** to register the dashboard. Set
+   \`title\` and \`description\` so a teammate can find it later.
+4. Optionally call **\`dashboards.request_refresh\`** to populate the
+   first snapshot. Otherwise widgets render "never refreshed" until cron
+   fires or a user clicks \u21BB.
+
+**Refresh loop \u2014 run whenever invoked:**
+
+1. Call **\`dashboards.pending_refreshes\`**. Returns widgets queued for
+   refresh with \`{slug, widget_id, kind, prompt, schema}\`.
+2. For each: read the prompt \u2192 use your tools (kanban, knowledge, your
+   integrations) to gather data \u2192 format to match the schema exactly \u2192
+   call **\`dashboards.persist_widget\`** with the result.
+3. Server validates against the schema; invalid output is rejected.
+
+**If you don't see \`dashboards.upsert\` in your tool list, STOP and ask
+the user.** The console dashboards system is the canonical surface, but
+the tool may not yet be deployed in your environment. In that case:
+
+> "I don't see the dashboards platform tool in my session. Do you want me
+> to wait until it's deployed, or build a one-off (static HTML, screenshot,
+> CSV) for now?"
+
+Do NOT silently fall back to writing Python pipelines, Chart.js HTML,
+headless-Chrome screenshots, or any other bespoke rendering path. Those
+are dead-ends \u2014 they live on disk for one session, can't be refreshed,
+and don't show up in the console where teammates look. Ask first; let
+the user decide whether the gap is worth a workaround.
+
+**Rules:**
+
+- **Always quote the full URL when you tell the user a dashboard is live.**
+  \`dashboards.upsert\` returns the absolute URL \u2014 paste that link verbatim,
+  never a relative path like "/dashboards" or "in the console". Bad:
+  "live in the console under /dashboards". Good:
+  "live at ${consoleUrl ? consoleUrl + "/dashboards/<id>" : "<console>/dashboards/<id>"}".
+  The same rule applies to \`dashboards.show\` and \`dashboards.list\` \u2014
+  surface the URL they returned so a teammate can click straight through.
+- Never invent figures. If a tool returned nothing, persist zeros / empty
+  arrays \u2014 don't fabricate plausible-looking numbers.
+- Don't write a dashboard to any other destination (GitHub Pages, S3, a
+  shared markdown doc, a Telegram \`sendPhoto\`, a one-off /tmp file)
+  unless the user explicitly asks for one of those formats. The console
+  is the answer.
+- One LLM call per widget on refresh \u2014 don't bundle widgets into a
+  single prompt; you'll lose schema strictness.
+- See \`.claude/skills/dashboards/SKILL.md\` (if installed) for the
+  canonical kpi/area/line/bar/donut JSON Schemas you can copy.
+
+## Development Workflow
 
 ### Repository Management
 
@@ -3136,6 +3261,10 @@ function buildMcpJson(input) {
       AGT_API_KEY: process.env["AGT_API_KEY"] ?? "",
       AGT_AGENT_ID: input.agent.agent_id,
       AGT_AGENT_CODE_NAME: input.agent.code_name,
+      // Console origin so the MCP bridge can build absolute URLs (e.g.
+      // dashboard links) in tool replies. Falls back to NEXT_PUBLIC_APP_URL
+      // / AGT_CONSOLE_URL — same chain consoleUrl uses for kanban links.
+      AGT_APP_URL: process.env["AGT_APP_URL"] ?? process.env["NEXT_PUBLIC_APP_URL"] ?? process.env["AGT_CONSOLE_URL"] ?? "",
       // Include PATH/HOME so the MCP subprocess can resolve binaries
       PATH: process.env["PATH"] ?? "",
       HOME: process.env["HOME"] ?? ""
@@ -3862,6 +3991,11 @@ ${sections}`
         maxBuffer: 1024 * 1024,
         env: {
           ...process.env,
+          // ENG-4510: prepend canonical brew + system bin dirs so hooks
+          // resolve binaries (npm, npx, qmd, xurl, …) when the manager is
+          // spawned from cloud-init with a minimal PATH. Otherwise hooks
+          // exit 127 ("command not found") on fresh prod EC2 hosts.
+          PATH: augmentedHookPath(process.env.PATH),
           AGENT_CODE_NAME: ctx.codeName,
           AGENT_DIR: agentRootDir,
           AGENT_PROJECT_DIR: projectDir,
@@ -3976,7 +4110,16 @@ These credentials are pre-loaded. Reference them by their environment variable n
 
 The only things that don't need a task: one-line answers, yes/no questions, simple factual lookups you can answer in under 30 seconds, or no-action acknowledgments ("thanks", "got it", "acknowledged", "will do") that require no further work. Everything else gets a task.
 
-The cost of an unnecessary task is near zero. The cost of invisible work is confusion, duplication, and lost context.`);
+The cost of an unnecessary task is near zero. The cost of invisible work is confusion, duplication, and lost context.
+
+**Always confirm task creation back to the requester via the same channel they reached you on.** When you create a kanban task in response to a Slack/direct-chat/email/etc. message, your *next* action MUST be to call that channel's send/reply tool with:
+
+  (a) a one-line acknowledgment of what you'll do, and
+  (b) **the full kanban deep link URL** \u2014 quote it verbatim from the kanban tool's response, including the \`https://\` prefix and the full path (use the exact \`https://...\` URL the tool emits \u2014 do not invent or rewrite it). Identifiers, short slugs, or "see kanban" references are not acceptable substitutes \u2014 the user must be able to click straight through.
+
+The kanban tools include the deep-link URL in their response. Locate the full URL in the tool result text (or in its \`details\` payload) and copy it verbatim into your channel reply, regardless of the surrounding sentence shape. The user has no way to see your kanban unless you give them the link \u2014 silent task creation feels like you ignored them.
+
+**Your turn is not finished until you reply on the channel.** If a user contacted you via a channel tool, you must end the turn by calling that channel's reply tool. Do not just emit assistant text and stop \u2014 text emitted without a channel-reply tool call is invisible to the user. This applies to every reply, not only kanban acknowledgments: confirmation questions, status updates, results, and final answers all need to go through the channel tool.`);
   return sections.join("\n\n");
 }
 function stripFrontmatter(content) {
@@ -4933,6 +5076,14 @@ function looksLikeNotesOnly(remainder) {
   return lines.every((line) => NON_DELIVERABLE_REMAINDER_PATTERNS.some((pattern) => pattern.test(line)));
 }
 
+// ../../packages/core/dist/types/kanban.js
+function formatActorId(kind, id) {
+  return `${kind}:${id}`;
+}
+function isSelfCompletion(event) {
+  return event.last_actor_id === formatActorId("agent", event.agent_id);
+}
+
 // ../../packages/core/dist/schemas/validators.js
 import Ajv2020 from "ajv/dist/2020.js";
 import addFormats from "ajv-formats";
@@ -6893,6 +7044,7 @@ export {
   getChannel,
   getAllChannelIds,
   getIntegration,
+  extractCommandNotFound,
   provisionStopHook,
   provisionIsolationHook,
   setJsonMode,
@@ -6912,6 +7064,8 @@ export {
   warn,
   info,
   table,
+  formatActorId,
+  isSelfCompletion,
   resolveChannels,
   SLACK_SCOPE_CATEGORY_LABELS,
   getDefaultSlackScopes,
@@ -6939,4 +7093,4 @@ export {
   managerStopCommand,
   managerStatusCommand
 };
-//# sourceMappingURL=chunk-WB3T6XIV.js.map
+//# sourceMappingURL=chunk-7QE6SJQB.js.map