@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.29 → 0.1.30

package/bin/adl

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/bin/adl
 size: 82912736 bytes
-sha256: 2b01ff7bfab3461ee9bc678cd6c7660691505b0bebd617f922de743b0187e197
+sha256: 54d5ec51e9782dda1e62b53d0b327b29028088a68fb4eed8f27cc195d53819c5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amsterdamdatalabs/adl-agent-control-linux-x64",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "adl CLI binary for linux/x64 (agent identity + Azure DevOps front door — see docs/architecture/cli-design.md)",
   "license": "UNLICENSED",
   "os": [

package/packages/agent-hooks/src/cli/args.ts

@@ -11,7 +11,7 @@
 
 import { readFileSync, statSync } from 'node:fs'
 import { resolve } from 'node:path'
-import { decodeConfig, type AdlRepoConfig } from '../gating/config.ts'
+import { decodeConfig, describeConfigIssue, type AdlRepoConfig } from '../gating/config.ts'
 import { MARKER, realRootIO, resolveManagedRepo } from '../gating/root.ts'
 import type { HookResult } from '../hooks/contract.ts'
 
@@ -88,7 +88,7 @@ export function loadRepo(cwd: string, repoArg: string | undefined): LoadedRepo |
   if (managed.configPath === null) return { ok: true, state, config: defaultConfig() }
   const decoded = decodeConfig(readFileSync(managed.configPath, 'utf8'))
   if (!decoded.ok) {
-    return { ok: false, state, error: `invalid ${managed.configPath} at ${decoded.issue.pointer}: ${decoded.issue.message}` }
+    return { ok: false, state, error: describeConfigIssue(managed.configPath, decoded.issue) }
   }
   return { ok: true, state, config: decoded.value }
 }

package/packages/agent-hooks/src/cli/doctor.ts

@@ -33,6 +33,7 @@ import { scanSkills } from '../hooks/user-prompt-submit/skills.ts'
 import { loadTokenizer } from '../hooks/user-prompt-submit/tokenizer.ts'
 import { loadVectorHalf, resolveGlobalArtifactDir } from '../hooks/user-prompt-submit/vector.ts'
 import { HOOKS_DENY_LOG_REL, HOOKS_LOG_REL } from '../hooks/log.ts'
+import { runningAdl } from '../gating/running-adl.ts'
 import { buildEngineContext } from '../rules/engine.ts'
 import { liveEnv, liveRepoIndex } from '../rules/ports.ts'
 import { BUILTIN_RULES, requireRegistered } from '../rules/registry.ts'
@@ -67,7 +68,7 @@ function repoChecks(loaded: LoadedRepo): { readonly checks: Check[]; readonly co
   if (!loaded.ok) return { checks: [repoLine, check('FAIL', 'config', loaded.error)], config: null }
   const root = state.root as string
   const ctx = buildEngineContext(loaded.config.rules, loaded.config.repo, requireRegistered(BUILTIN_RULES), liveRepoIndex(root), liveEnv, undefined, loaded.config.agent)
-  if (!ctx.ok) return { checks: [repoLine, check('FAIL', 'config', `${ctx.issue.pointer}: ${ctx.issue.message}`)], config: null }
+  if (!ctx.ok) return { checks: [repoLine, check('FAIL', 'config', `${ctx.issue.pointer}: ${ctx.issue.message}${runningAdl()}`)], config: null }
   return { checks: [repoLine, check('ok', 'config', 'valid')], config: loaded.config }
 }
 

package/packages/agent-hooks/src/cli/rules.ts

@@ -13,6 +13,7 @@
 
 import { buildEngineContext } from '../rules/engine.ts'
 import { liveEnv, liveRepoIndex } from '../rules/ports.ts'
+import { runningAdl } from '../gating/running-adl.ts'
 import { BUILTIN_RULES, requireRegistered } from '../rules/registry.ts'
 import type { AnyRuleSpec } from '../rules/spec.ts'
 import { type CliResult, type RepoState, cliError, loadRepo, parseArgs, unmanagedReason } from './args.ts'
@@ -42,7 +43,7 @@ function resolveRules(cwd: string, repoArg: string | undefined): Resolved | CliR
   const { state, config } = loaded
   const registered = requireRegistered(BUILTIN_RULES)
   const ctx = buildEngineContext(config.rules, config.repo, registered, liveRepoIndex(state.root ?? state.start), liveEnv, undefined, config.agent)
-  if (!ctx.ok) return cliError(`${state.configPath} ${ctx.issue.pointer}: ${ctx.issue.message}`)
+  if (!ctx.ok) return cliError(`${state.configPath} ${ctx.issue.pointer}: ${ctx.issue.message}${runningAdl()}`)
   const hooksEnabled = config.hooks.enabled
   const rules = [...registered.values()].map((spec) => ({
     spec,

package/packages/agent-hooks/src/gating/config.ts

@@ -62,6 +62,7 @@
  */
 
 import { MARKER } from './root.ts'
+import { runningAdl } from './running-adl.ts'
 
 interface RuleSection {
   readonly enabled: boolean
@@ -146,6 +147,16 @@ export interface AdlRepoConfig {
 
 export type ConfigDecodeIssue = { readonly pointer: string; readonly message: string }
 
+/**
+ * The one place a config-decode failure is rendered for an operator:
+ * `invalid <config> at <pointer>: <message> (adl <version> at <exec path>)`
+ * (`./running-adl.ts`). Added at rendering only — `ConfigDecodeIssue` stays
+ * untouched for programmatic consumers.
+ */
+export function describeConfigIssue(configPath: string, issue: ConfigDecodeIssue): string {
+  return `invalid ${configPath} at ${issue.pointer}: ${issue.message}${runningAdl()}`
+}
+
 export type ConfigDecodeResult =
   | { readonly ok: true; readonly value: AdlRepoConfig }
   | { readonly ok: false; readonly issue: ConfigDecodeIssue }

package/packages/agent-hooks/src/gating/running-adl.ts

@@ -0,0 +1,24 @@
+/**
+ * Which adl is decoding the config. A stale binary rejecting a newer config's
+ * keys ("unknown key(s) 'fleet'") looks identical to a bad config, so every
+ * config rejection an operator sees carries `(adl <version> at <exec path>)`.
+ *
+ * The version belongs to the CLI (`apps/cli/package.json`, what `adl
+ * --version` prints). This package must not import upward into the app, so
+ * `adl hook` injects it through `run(argv, adlVersion)` in `../main.ts`. A
+ * caller that does not inject one (the standalone agent-hooks entry, in-process
+ * tests) renders `version unknown` — never a made-up number.
+ *
+ * The path is `process.execPath`: the compiled binary itself (there
+ * `process.argv[1]` is a virtual `/$bunfs` path); under `bun run` it is bun,
+ * which is what is actually running.
+ */
+let injectedVersion: string | undefined;
+
+export function setRunningAdlVersion(version: string | undefined): void {
+  injectedVersion = version;
+}
+
+export function runningAdl(): string {
+  return ` (adl ${injectedVersion ?? "version unknown"} at ${process.execPath})`;
+}

package/packages/agent-hooks/src/hooks/user-prompt-submit/handler.ts

@@ -15,7 +15,7 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import type { HookHandler, HookInvocation } from '../contract.ts'
-import { decodeConfig } from '../../gating/config.ts'
+import { decodeConfig, describeConfigIssue } from '../../gating/config.ts'
 import { MARKER } from '../../gating/root.ts'
 import { DEFAULT_SKILLS_DIR } from './constants.ts'
 import { skillRootsFor } from './skill-roots.ts'
@@ -52,7 +52,7 @@ function resolveSkillRoots(inv: HookInvocation): readonly string[] {
   const text = readFileSync(configPath, 'utf8')
   const decoded = decodeConfig(text)
   if (!decoded.ok) {
-    throw new Error(`invalid ${configPath} at ${decoded.issue.pointer}: ${decoded.issue.message}`)
+    throw new Error(describeConfigIssue(configPath, decoded.issue))
   }
 
   const explicit = decoded.value.hooks.skillsDir

package/packages/agent-hooks/src/main.ts

@@ -72,7 +72,8 @@ import type { HookHandler, HookInvocation, HookResult } from './hooks/contract.t
 import { payloadCwd } from './hooks/contract.ts'
 import { resolveHost, readHostFlag, type HostId } from './hosts/spec.ts'
 import { resolveManagedRepo, realRootIO } from './gating/root.ts'
-import { decodeConfig, type AdlRepoConfig } from './gating/config.ts'
+import { setRunningAdlVersion } from './gating/running-adl.ts'
+import { decodeConfig, describeConfigIssue, type AdlRepoConfig } from './gating/config.ts'
 import { FAIL_CLOSED_EXIT_CODE } from './rules/engine.ts'
 import { handlePreToolUse } from './pre-tool-use/handler.ts'
 import { handleUserPromptSubmit } from './hooks/user-prompt-submit/handler.ts'
@@ -123,7 +124,13 @@ function writeResult(result: HookResult): number {
   return result.exitCode
 }
 
-export async function run(argv: readonly string[]): Promise<number> {
+/**
+ * `adlVersion` is the embedding CLI's version (`adl hook` passes
+ * `apps/cli/package.json`'s); the standalone entry passes none, and config
+ * errors then say `version unknown` rather than guess.
+ */
+export async function run(argv: readonly string[], adlVersion?: string): Promise<number> {
+  setRunningAdlVersion(adlVersion)
   if (argv.includes('--version')) {
     process.stdout.write(`${readPackageVersion()}\n`)
     return 0
@@ -199,7 +206,7 @@ export async function run(argv: readonly string[]): Promise<number> {
     const decoded = decodeConfig(text)
     if (!decoded.ok) {
       process.stderr.write(
-        `adl hook: invalid ${managed.configPath} at ${decoded.issue.pointer}: ${decoded.issue.message}\n`,
+        `adl hook: ${describeConfigIssue(managed.configPath, decoded.issue)}\n`,
       )
       return 1
     }

package/packages/agent-hooks/src/pre-tool-use/handler.ts

@@ -19,7 +19,8 @@
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import type { ActivityNote, HookInvocation, HookResult } from '../hooks/contract.ts'
-import { decodeConfig } from '../gating/config.ts'
+import { decodeConfig, describeConfigIssue } from '../gating/config.ts'
+import { runningAdl } from '../gating/running-adl.ts'
 import { MARKER } from '../gating/root.ts'
 import {
   buildEngineContext,
@@ -221,7 +222,7 @@ export async function handlePreToolUse(inv: HookInvocation): Promise<HookResult>
   const text = readFileSync(configPath, 'utf8')
   const decoded = decodeConfig(text)
   if (!decoded.ok) {
-    throw new Error(`adl hook: invalid ${configPath} at ${decoded.issue.pointer}: ${decoded.issue.message}`)
+    throw new Error(`adl hook: ${describeConfigIssue(configPath, decoded.issue)}`)
   }
   const config = decoded.value
 
@@ -243,10 +244,10 @@ export async function handlePreToolUse(inv: HookInvocation): Promise<HookResult>
   inv.root,
 )
   if (!ctx.ok) {
-    inv.record?.({ reason: 'ERROR rules config', message: `adl hook: ${configPath} ${ctx.issue.pointer}: ${ctx.issue.message}` })
+    inv.record?.({ reason: 'ERROR rules config', message: `adl hook: ${configPath} ${ctx.issue.pointer}: ${ctx.issue.message}${runningAdl()}` })
     return {
       stdout: '',
-      stderr: `adl hook: ${configPath} ${ctx.issue.pointer}: ${ctx.issue.message}\n`,
+      stderr: `adl hook: ${configPath} ${ctx.issue.pointer}: ${ctx.issue.message}${runningAdl()}\n`,
       exitCode: FAIL_CLOSED_EXIT_CODE,
     }
   }

package/packages/azdo/src/azdo-wit.ts

@@ -42,7 +42,12 @@ const isAllowedType = (type: string | undefined): type is AllowedType => (ALLOWE
 function assertAllowedType(type: string | undefined): asserts type is AllowedType {
   if (!isAllowedType(type)) throw new Error(`type must be one of ${ALLOWED_TYPES.join(', ')}; got ${type ?? 'undefined'}`);
 }
-function formatItem(wi: any, raw: boolean): Record<string, unknown> {
+interface WorkItemView {
+  id: number; title: string; type: string; state: string; assignedTo: string | undefined; description: string | undefined; url: string | undefined;
+  links: { parent: number | null; children: number[]; predecessors: number[]; successors: number[]; related: number[] };
+  effort: number | null; failureReason: string | null; fields?: Record<string, unknown>; relations?: unknown[];
+}
+function formatItem(wi: any, raw: boolean): WorkItemView {
   const fields = wi.fields ?? {};
   const relationId = (url: string) => Number(/(\d+)\/?$/.exec(url)?.[1]);
   const links = { parent: null as number | null, children: [] as number[], predecessors: [] as number[], successors: [] as number[], related: [] as number[] };
@@ -53,7 +58,8 @@ function formatItem(wi: any, raw: boolean): Record<string, unknown> {
     if (relation.rel === 'System.LinkTypes.Dependency-Forward') links.successors.push(relationId(relation.url));
     if (relation.rel === 'System.LinkTypes.Related') links.related.push(relationId(relation.url));
   }
-  const out: Record<string, unknown> = { id: wi.id, title: fields['System.Title'], type: fields['System.WorkItemType'], state: fields['System.State'], assignedTo: fields['System.AssignedTo']?.displayName, description: fields['System.Description'], url: wi._links?.html?.href, links, customFields: Object.fromEntries(Object.entries(fields).filter(([name]) => name.startsWith('Custom.'))) };
+  const effort = fields['Microsoft.VSTS.Scheduling.Effort']; const failureReason = fields['Custom.FailureReason'];
+  const out: WorkItemView = { id: wi.id, title: fields['System.Title'], type: fields['System.WorkItemType'], state: fields['System.State'], assignedTo: fields['System.AssignedTo']?.displayName, description: fields['System.Description'], url: wi._links?.html?.href, links, effort: typeof effort === 'number' ? effort : null, failureReason: typeof failureReason === 'string' && failureReason ? failureReason : null };
   if (raw) { out.fields = fields; out.relations = wi.relations ?? []; }
   return out;
 }

package/packages/azdo/src/mcp-server.ts

@@ -124,7 +124,7 @@ export function createServer(): Server {
       },
       {
         name: 'workitem_list_or_get',
-        description: 'Get one or many tracked work items, or query the scoped backlog.',
+        description: 'Get one or many tracked work items, or query the scoped backlog. Each item carries effort and failureReason (both null when unset).',
         inputSchema: {
           type: 'object',
           properties: {

package/packages/repo-controls/scripts/hooks/pre-push

@@ -22,8 +22,12 @@ push_updates="$(cat)"
 # released on EXIT, which serialised THIS HOOK rather than the network push,
 # so the window it claimed to close stayed open the whole time.
 PUSH_TREE=""
+PUSH_ARCHIVE=""
 cleanup_pre_push() {
   local status=$?
+  if [[ -n "${PUSH_ARCHIVE}" && -e "${PUSH_ARCHIVE}" ]]; then
+    rm -f -- "${PUSH_ARCHIVE}"
+  fi
   if [[ -n "${PUSH_TREE}" && -d "${PUSH_TREE}" ]]; then
     rm -rf -- "${PUSH_TREE}"
   fi
@@ -109,7 +113,13 @@ if [[ -f "$STATIC_CACHE" ]]; then
 else
   echo 'pre-push: exporting HEAD tree for static checks'
   PUSH_TREE="$(mktemp -d "${TMPDIR:-/tmp}/adl-pre-push-head.XXXXXX")"
-  git archive HEAD | tar -x -C "$PUSH_TREE"
+  # Not `git archive HEAD | tar -x`: on the macOS CI agent that pipe failed
+  # pushes with 141 (SIGPIPE under pipefail) -- a tar that stops reading before
+  # git archive finishes writing kills the writer. A file has no reader to lose.
+  PUSH_ARCHIVE="${PUSH_TREE}.tar"
+  git archive --format=tar -o "$PUSH_ARCHIVE" HEAD
+  tar -xf "$PUSH_ARCHIVE" -C "$PUSH_TREE"
+  rm -f -- "$PUSH_ARCHIVE"
   # Untracked paths the export needs, declared by the repository. This was
   # `ln -s "$ROOT/node_modules"` -- a package that calls itself language
   # agnostic assuming JavaScript. A Rust repo links `target/`, a Python one its