@pellux/goodvibes-agent 1.1.7 → 1.2.0

package/src/agent/harness-control.ts

@@ -163,8 +163,8 @@ export function redactHarnessSettingValue(key: string, value: unknown): unknown
 }
 
 function settingModelRoute(setting: ConfigSetting): string {
-  if (isExternalHostOwnedSettingKey(setting.key)) return 'agent_harness mode:"get_setting" only';
-  return 'agent_harness mode:"set_setting" or mode:"reset_setting"';
+  if (isExternalHostOwnedSettingKey(setting.key)) return `settings get key:${setting.key}`;
+  return `settings set|reset key:${setting.key}`;
 }
 
 export function describeHarnessSetting(

package/src/agent/memory-prompt.ts

@@ -1,6 +1,6 @@
 import type { MemoryRecord, MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
 const DEFAULT_LIMIT = 10;
-export const MIN_PROMPT_MEMORY_CONFIDENCE = 50;
+export const MIN_PROMPT_MEMORY_CONFIDENCE = 70;
 
 export function isPromptActiveMemory(record: MemoryRecord): boolean {
   return record.reviewState === 'reviewed' && record.confidence >= MIN_PROMPT_MEMORY_CONFIDENCE;
@@ -28,7 +28,7 @@ export function buildReviewedMemoryPrompt(memoryRegistry: MemoryRegistry, limit
   if (records.length === 0) return null;
   return [
     '## Reviewed GoodVibes Agent Memory',
-    'Use these local, reviewed, non-secret memory records to avoid asking repeat questions and to preserve durable user preferences, constraints, and operating facts.',
+    `Use these local, reviewed, non-secret memory records with confidence >= ${MIN_PROMPT_MEMORY_CONFIDENCE}% to avoid asking repeat questions and to preserve durable user preferences, constraints, and operating facts.`,
     ...records.map(formatMemoryLine),
   ].join('\n');
 }

package/src/agent/operator-actions.ts

@@ -1,4 +1,5 @@
 import type { OperatorMethodInput } from '@pellux/goodvibes-sdk/contracts';
+import { scheduleNextRouteLines } from './schedule-next-routes.ts';
 
 export type JsonRecord = Record<string, unknown>;
 
@@ -9,8 +10,12 @@ export type AutomationActionId =
   | 'automation.jobs.resume'
   | 'automation.runs.cancel'
   | 'automation.runs.retry'
+  | 'schedules.delete'
+  | 'schedules.disable'
+  | 'schedules.enable'
   | 'schedules.run';
 export type OperatorActionId = ApprovalActionId | AutomationActionId;
+export type OperatorActionHttpMethod = 'POST' | 'DELETE';
 
 type ApprovalActionInput =
   | OperatorMethodInput<'approvals.approve'>
@@ -33,6 +38,7 @@ export interface OperatorActionDescriptor {
   readonly label: string;
   readonly pathTemplate: string;
   readonly targetField: 'approvalId' | 'jobId' | 'runId' | 'scheduleId';
+  readonly httpMethod?: OperatorActionHttpMethod;
 }
 
 export interface OperatorActionRequest {
@@ -45,6 +51,7 @@ export interface OperatorActionRequest {
 export interface OperatorActionSuccess {
   readonly ok: true;
   readonly methodId: OperatorActionId;
+  readonly httpMethod: OperatorActionHttpMethod;
   readonly path: string;
   readonly body: unknown;
 }
@@ -58,6 +65,7 @@ export interface OperatorActionFailure {
     | 'connected_host_error';
   readonly error: string;
   readonly methodId: OperatorActionId;
+  readonly httpMethod: OperatorActionHttpMethod;
   readonly path: string;
 }
 
@@ -125,6 +133,25 @@ export const OPERATOR_ACTIONS: Record<OperatorActionId, OperatorActionDescriptor
     pathTemplate: '/api/automation/schedules/{scheduleId}/run',
     targetField: 'scheduleId',
   },
+  'schedules.enable': {
+    action: 'schedules.enable',
+    label: 'enable schedule',
+    pathTemplate: '/api/automation/schedules/{scheduleId}/enable',
+    targetField: 'scheduleId',
+  },
+  'schedules.disable': {
+    action: 'schedules.disable',
+    label: 'disable schedule',
+    pathTemplate: '/api/automation/schedules/{scheduleId}/disable',
+    targetField: 'scheduleId',
+  },
+  'schedules.delete': {
+    action: 'schedules.delete',
+    label: 'delete schedule',
+    pathTemplate: '/api/automation/schedules/{scheduleId}',
+    targetField: 'scheduleId',
+    httpMethod: 'DELETE',
+  },
 };
 
 export const OPERATOR_ACTION_IDS = Object.keys(OPERATOR_ACTIONS) as readonly OperatorActionId[];
@@ -154,6 +181,10 @@ export function renderOperatorActionPath(descriptor: OperatorActionDescriptor, t
   return descriptor.pathTemplate.replace(`{${descriptor.targetField}}`, encodeURIComponent(targetId));
 }
 
+export function operatorActionHttpMethod(descriptor: OperatorActionDescriptor): OperatorActionHttpMethod {
+  return descriptor.httpMethod ?? 'POST';
+}
+
 function approvalBody(args: OperatorActionArgs): ApprovalActionInput {
   const note = readOperatorActionString(args.note);
   const body: ApprovalActionInput = {
@@ -214,6 +245,7 @@ function summarizeError(error: unknown): string {
 
 function classifyHttpFailure(
   methodId: OperatorActionId,
+  httpMethod: OperatorActionHttpMethod,
   path: string,
   status: number,
   body: unknown,
@@ -222,6 +254,7 @@ function classifyHttpFailure(
   return {
     ok: false,
     methodId,
+    httpMethod,
     path,
     kind: status === 401 || status === 403
       ? 'auth_required'
@@ -237,11 +270,13 @@ export async function postOperatorAction(
   request: OperatorActionRequest,
 ): Promise<OperatorActionResult> {
   const path = renderOperatorActionPath(request.descriptor, request.targetId);
+  const httpMethod = operatorActionHttpMethod(request.descriptor);
   const token = connection.token;
   if (!token) {
     return {
       ok: false,
       methodId: request.descriptor.action,
+      httpMethod,
       path,
       kind: 'auth_required',
       error: connection.tokenPath ? `no connected-host operator token found at ${connection.tokenPath}` : 'no connected-host operator token found',
@@ -251,7 +286,7 @@ export async function postOperatorAction(
     authorization: `Bearer ${token}`,
   };
   const init: RequestInit = {
-    method: 'POST',
+    method: httpMethod,
     headers,
   };
   if (request.body) {
@@ -261,10 +296,11 @@ export async function postOperatorAction(
   try {
     const response = await fetch(`${connection.baseUrl}${path}`, init);
     const body = await readResponseBody(response);
-    if (!response.ok) return classifyHttpFailure(request.descriptor.action, path, response.status, body);
+    if (!response.ok) return classifyHttpFailure(request.descriptor.action, httpMethod, path, response.status, body);
     return {
       ok: true,
       methodId: request.descriptor.action,
+      httpMethod,
       path,
       body,
     };
@@ -272,6 +308,7 @@ export async function postOperatorAction(
     return {
       ok: false,
       methodId: request.descriptor.action,
+      httpMethod,
       path,
       kind: 'connected_host_unavailable',
       error: summarizeError(error),
@@ -297,13 +334,20 @@ function formatOperatorActionFailureKind(kind: OperatorActionFailure['kind']): s
   return 'connected host error';
 }
 
+function scheduleIdFromActionPath(path: string): string {
+  const match = /\/api\/automation\/schedules\/([^/]+)/.exec(path);
+  return match?.[1] ? decodeURIComponent(match[1]) : '';
+}
+
 export function formatOperatorActionSuccess(baseUrl: string, result: OperatorActionSuccess): string {
+  const scheduleId = result.methodId.startsWith('schedules.') ? scheduleIdFromActionPath(result.path) : '';
   return [
     'Agent operator action completed',
     `  method: ${result.methodId}`,
-    `  route: POST ${result.path}`,
+    `  route: ${result.httpMethod} ${result.path}`,
     `  connected host: ${baseUrl}`,
     `  status: ${statusFromOperatorActionBody(result.body)}`,
+    ...(scheduleId ? scheduleNextRouteLines(scheduleId, { deleted: result.methodId === 'schedules.delete' }) : []),
   ].join('\n');
 }
 
@@ -311,7 +355,7 @@ export function formatOperatorActionFailure(result: OperatorActionFailure): stri
   return [
     `Agent operator action failed: ${result.kind} (${formatOperatorActionFailureKind(result.kind)})`,
     `  method: ${result.methodId}`,
-    `  route: POST ${result.path}`,
+    `  route: ${result.httpMethod} ${result.path}`,
     `  error: ${result.error}`,
   ].join('\n');
 }
@@ -322,7 +366,7 @@ export function formatOperatorActionPreview(request: OperatorActionRequest, expl
     `  method ${request.descriptor.action}`,
     `  action ${request.descriptor.label}`,
     `  target ${request.targetId}`,
-    `  route POST ${renderOperatorActionPath(request.descriptor, request.targetId)}`,
+    `  route ${operatorActionHttpMethod(request.descriptor)} ${renderOperatorActionPath(request.descriptor, request.targetId)}`,
     explicitUserRequest ? `  requested by ${explicitUserRequest}` : '  requested by (missing)',
     '',
     'Confirmation required: type yes in the workspace form or pass --yes only when the user explicitly asked GoodVibes Agent to perform this exact operator action.',
@@ -335,7 +379,7 @@ export function formatOperatorActionToolPreview(request: OperatorActionRequest,
     `  method ${request.descriptor.action}`,
     `  action ${request.descriptor.label}`,
     `  target ${request.targetId}`,
-    `  route POST ${renderOperatorActionPath(request.descriptor, request.targetId)}`,
+    `  route ${operatorActionHttpMethod(request.descriptor)} ${renderOperatorActionPath(request.descriptor, request.targetId)}`,
     explicitUserRequest ? `  requested by ${explicitUserRequest}` : '  requested by (missing)',
     '',
     'Model tool confirmation required. Call this tool with confirm:true only when the user explicitly asked GoodVibes Agent to perform this exact operator action.',

package/src/agent/persona-registry.ts

@@ -369,6 +369,14 @@ export class AgentPersonaRegistry {
 export function buildActivePersonaPrompt(shellPaths: ShellPathService): string | null {
   const active = AgentPersonaRegistry.fromShellPaths(shellPaths).snapshot().activePersona;
   if (!active) return null;
+  if (active.reviewState !== 'reviewed') {
+    return [
+      '## Active GoodVibes Agent Persona',
+      `Name: ${active.name}`,
+      `Review: ${formatAgentRecordReviewState(active.reviewState)}`,
+      'This persona is active but not applied because it is not reviewed. Use the learning curator or persona review route before allowing it to steer assistant behavior.',
+    ].join('\n');
+  }
   return [
     '## Active GoodVibes Agent Persona',
     `Name: ${active.name}`,

package/src/agent/project-context-files.ts

@@ -0,0 +1,273 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { assertNoSecretLikeText } from './persona-registry.ts';
+
+export type AgentProjectContextKind =
+  | 'hermes'
+  | 'agents'
+  | 'claude'
+  | 'soul'
+  | 'cursor';
+
+export type AgentProjectContextScope = 'project' | 'subdirectory' | 'cwd' | 'global';
+
+export interface AgentProjectContextFile {
+  readonly id: string;
+  readonly path: string;
+  readonly kind: AgentProjectContextKind;
+  readonly scope: AgentProjectContextScope;
+  readonly source: string;
+  readonly priority: number;
+  readonly body: string;
+  readonly truncated: boolean;
+}
+
+export interface BlockedAgentProjectContextFile {
+  readonly id: string;
+  readonly path: string;
+  readonly kind: AgentProjectContextKind;
+  readonly scope: AgentProjectContextScope;
+  readonly source: string;
+  readonly priority: number;
+  readonly reason: string;
+}
+
+export interface AgentProjectContextSnapshot {
+  readonly files: readonly AgentProjectContextFile[];
+  readonly blocked: readonly BlockedAgentProjectContextFile[];
+  readonly searchedPaths: readonly string[];
+  readonly workingDirectory: string;
+  readonly targetDirectory: string;
+  readonly gitRoot: string | null;
+  readonly progressiveTargetAware: boolean;
+}
+
+type AgentProjectContextPaths = Pick<ShellPathService, 'workingDirectory' | 'homeDirectory' | 'expandHomePath' | 'resolveWorkspacePath'>;
+
+interface CandidateContextFile {
+  readonly path: string;
+  readonly kind: AgentProjectContextKind;
+  readonly scope: AgentProjectContextScope;
+  readonly source: string;
+  readonly priority: number;
+}
+
+export interface AgentProjectContextDiscoveryOptions {
+  readonly targetPath?: string;
+}
+
+const MAX_CONTEXT_FILE_CHARS = 10_000;
+const MAX_TOTAL_CONTEXT_CHARS = 32_000;
+const MAX_PROJECT_DEPTH = 32;
+
+function safeStat(path: string): ReturnType<typeof statSync> | null {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+
+function findGitRoot(workingDirectory: string): string | null {
+  let current = resolve(workingDirectory);
+  for (let depth = 0; depth < MAX_PROJECT_DEPTH; depth += 1) {
+    if (existsSync(join(current, '.git'))) return current;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+function pathInside(parent: string, child: string): boolean {
+  const rel = relative(resolve(parent), resolve(child));
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+function resolveTargetDirectory(shellPaths: AgentProjectContextPaths, targetPath?: string): string {
+  const trimmed = typeof targetPath === 'string' ? targetPath.trim() : '';
+  if (!trimmed) return resolve(shellPaths.workingDirectory);
+  const expanded = shellPaths.expandHomePath(trimmed);
+  const resolved = isAbsolute(expanded) ? resolve(expanded) : shellPaths.resolveWorkspacePath(expanded);
+  if (!pathInside(shellPaths.workingDirectory, resolved)) return resolve(shellPaths.workingDirectory);
+  const stat = safeStat(resolved);
+  return stat?.isDirectory() ? resolved : dirname(resolved);
+}
+
+function contextWalkRoots(workingDirectory: string, targetDirectory: string): { readonly roots: readonly string[]; readonly gitRoot: string | null } {
+  const gitRoot = findGitRoot(workingDirectory);
+  const start = gitRoot && pathInside(gitRoot, targetDirectory) ? gitRoot : resolve(workingDirectory);
+  const roots: string[] = [];
+  let current = resolve(targetDirectory);
+  for (let depth = 0; depth < MAX_PROJECT_DEPTH; depth += 1) {
+    roots.push(current);
+    if (current === start) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return { roots: roots.reverse(), gitRoot };
+}
+
+function cursorRuleCandidates(workingDirectory: string): readonly CandidateContextFile[] {
+  const dir = join(workingDirectory, '.cursor', 'rules');
+  const stat = safeStat(dir);
+  if (!stat?.isDirectory()) return [];
+  try {
+    return readdirSync(dir)
+      .filter((entry) => entry.endsWith('.mdc'))
+      .sort((left, right) => left.localeCompare(right))
+      .map((entry, index) => ({
+        path: join(dir, entry),
+        kind: 'cursor' as const,
+        scope: 'cwd' as const,
+        source: '.cursor/rules/*.mdc',
+        priority: 70 + index,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+function candidateContextFiles(shellPaths: AgentProjectContextPaths, targetDirectory: string): readonly CandidateContextFile[] {
+  const { roots } = contextWalkRoots(shellPaths.workingDirectory, targetDirectory);
+  const candidates: CandidateContextFile[] = [];
+  const hermesHome = process.env.HERMES_HOME?.trim();
+  if (hermesHome) {
+    candidates.push({
+      path: join(shellPaths.expandHomePath(hermesHome), 'SOUL.md'),
+      kind: 'soul',
+      scope: 'global',
+      source: 'HERMES_HOME/SOUL.md',
+      priority: 10,
+    });
+  }
+
+  const workingDirectory = resolve(shellPaths.workingDirectory);
+  for (const [index, root] of roots.entries()) {
+    const scope: AgentProjectContextScope = root === workingDirectory ? 'cwd' : pathInside(workingDirectory, root) ? 'subdirectory' : 'project';
+    candidates.push(
+      { path: join(root, '.hermes.md'), kind: 'hermes', scope, source: '.hermes.md', priority: 20 + index },
+      { path: join(root, 'HERMES.md'), kind: 'hermes', scope, source: 'HERMES.md', priority: 25 + index },
+      { path: join(root, 'AGENTS.md'), kind: 'agents', scope, source: 'AGENTS.md', priority: 40 + index },
+      { path: join(root, 'CLAUDE.md'), kind: 'claude', scope, source: 'CLAUDE.md', priority: 55 + index },
+    );
+  }
+
+  candidates.push({
+    path: join(shellPaths.workingDirectory, '.cursorrules'),
+    kind: 'cursor',
+    scope: 'cwd',
+    source: '.cursorrules',
+    priority: 70,
+  });
+  candidates.push(...cursorRuleCandidates(shellPaths.workingDirectory));
+  return candidates;
+}
+
+function contextFileId(candidate: Pick<CandidateContextFile, 'path' | 'source'>): string {
+  const base = resolve(candidate.path).replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase();
+  return `${candidate.source.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase()}-${base || 'context'}`;
+}
+
+function dedupeCandidates(candidates: readonly CandidateContextFile[]): readonly CandidateContextFile[] {
+  const seen = new Set<string>();
+  const result: CandidateContextFile[] = [];
+  for (const candidate of candidates) {
+    const path = resolve(candidate.path);
+    if (seen.has(path)) continue;
+    seen.add(path);
+    result.push({ ...candidate, path });
+  }
+  return result;
+}
+
+function readContextCandidate(candidate: CandidateContextFile): AgentProjectContextFile | BlockedAgentProjectContextFile | null {
+  const stat = safeStat(candidate.path);
+  if (!stat?.isFile()) return null;
+  let content = '';
+  try {
+    content = readFileSync(candidate.path, 'utf-8');
+  } catch (error) {
+    return {
+      ...candidate,
+      id: contextFileId(candidate),
+      reason: `Could not read file: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+  const body = content.trim();
+  if (!body) {
+    return {
+      ...candidate,
+      id: contextFileId(candidate),
+      reason: 'File is empty.',
+    };
+  }
+  try {
+    assertNoSecretLikeText([content], 'Project context files');
+  } catch (error) {
+    return {
+      ...candidate,
+      id: contextFileId(candidate),
+      reason: error instanceof Error ? error.message : String(error),
+    };
+  }
+  return {
+    ...candidate,
+    id: contextFileId(candidate),
+    body: body.length > MAX_CONTEXT_FILE_CHARS ? body.slice(0, MAX_CONTEXT_FILE_CHARS).trimEnd() : body,
+    truncated: body.length > MAX_CONTEXT_FILE_CHARS,
+  };
+}
+
+export function discoverProjectContextFiles(
+  shellPaths: AgentProjectContextPaths,
+  options: AgentProjectContextDiscoveryOptions = {},
+): AgentProjectContextSnapshot {
+  const targetDirectory = resolveTargetDirectory(shellPaths, options.targetPath);
+  const { gitRoot } = contextWalkRoots(shellPaths.workingDirectory, targetDirectory);
+  const files: AgentProjectContextFile[] = [];
+  const blocked: BlockedAgentProjectContextFile[] = [];
+  const candidates = dedupeCandidates(candidateContextFiles(shellPaths, targetDirectory));
+  for (const candidate of candidates) {
+    const record = readContextCandidate(candidate);
+    if (!record) continue;
+    if ('body' in record) files.push(record);
+    else blocked.push(record);
+  }
+  files.sort((left, right) => left.priority - right.priority || left.path.localeCompare(right.path));
+  blocked.sort((left, right) => left.priority - right.priority || left.path.localeCompare(right.path));
+  return {
+    files,
+    blocked,
+    searchedPaths: candidates.map((candidate) => candidate.path),
+    workingDirectory: resolve(shellPaths.workingDirectory),
+    targetDirectory,
+    gitRoot,
+    progressiveTargetAware: targetDirectory !== resolve(shellPaths.workingDirectory),
+  };
+}
+
+export function buildProjectContextPrompt(shellPaths: AgentProjectContextPaths): string | null {
+  const snapshot = discoverProjectContextFiles(shellPaths);
+  if (snapshot.files.length === 0 && snapshot.blocked.length === 0) return null;
+  const lines: string[] = [
+    '## Project Context Files',
+    'These project-authored instructions shape the current workspace. Follow them only when they do not conflict with explicit user instructions, safety policy, tool contracts, confirmation requirements, or secret-handling rules.',
+  ];
+  let remaining = MAX_TOTAL_CONTEXT_CHARS;
+  for (const file of snapshot.files) {
+    if (remaining <= 0) break;
+    const body = file.body.slice(0, remaining).trimEnd();
+    remaining -= body.length;
+    lines.push('', `### ${file.source}`, `Source: ${file.path}`, `Kind: ${file.kind}; scope: ${file.scope}`, '', body);
+    if (file.truncated || body.length < file.body.length) lines.push('', `[${file.source} truncated for prompt safety.]`);
+  }
+  if (snapshot.blocked.length > 0) {
+    lines.push('', '### Blocked Project Context Files');
+    for (const blocked of snapshot.blocked) lines.push(`- ${blocked.path}: ${blocked.reason}`);
+    lines.push('Blocked project context content was not loaded.');
+  }
+  return lines.join('\n');
+}